openapi

type BadRequest = Error

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

	// Roles Examples: ["admin","user"]
	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 User login
	//
	// Log in with username/password to obtain an access token (JWT or OAuth2).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/auth/login (the `LoginUser` operationId).
	LoginUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// LoginUser User login
	//
	// Log in with username/password to obtain an access token (JWT or OAuth2).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/auth/login (the `LoginUser` operationId).
	LoginUser(ctx context.Context, body LoginUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// LogoutUser Logout user
	//
	// Invalidate the current token or session.
	//
	// Corresponds with POST /v1/auth/logout (the `LogoutUser` operationId).
	LogoutUser(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetCurrentUser Get current user info
	//
	// Retrieve the user profile data (including roles/claims) from the current session/token.
	//
	// Corresponds with GET /v1/auth/me (the `GetCurrentUser` operationId).
	GetCurrentUser(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RefreshTokenWithBody Refresh user token
	//
	// Obtain a new token using a valid refresh token.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/auth/refresh (the `RefreshToken` operationId).
	RefreshTokenWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RefreshToken Refresh user token
	//
	// Obtain a new token using a valid refresh token.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/auth/refresh (the `RefreshToken` operationId).
	RefreshToken(ctx context.Context, body RefreshTokenJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RegisterUserWithBody User registration
	//
	// Register a new user with username/password.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/auth/register (the `RegisterUser` operationId).
	RegisterUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RegisterUser User registration
	//
	// Register a new user with username/password.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/auth/register (the `RegisterUser` operationId).
	RegisterUser(ctx context.Context, body RegisterUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// EchoWithBody Echo
	//
	// Echo the provided message.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/echo (the `Echo` operationId).
	EchoWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// Echo Echo
	//
	// Echo the provided message.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/echo (the `Echo` operationId).
	Echo(ctx context.Context, body EchoJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListPets List all pets
	//
	// Retrieve a list (paged) of pets from the server.
	//
	// Corresponds with GET /v1/pets (the `ListPets` operationId).
	ListPets(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreatePetWithBody Create a pet
	//
	// Create a new pet in the server’s database.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/pets (the `CreatePet` operationId).
	CreatePetWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreatePet Create a pet
	//
	// Create a new pet in the server’s database.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/pets (the `CreatePet` operationId).
	CreatePet(ctx context.Context, body CreatePetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ShowPetById Show a specific pet
	//
	// Retrieve data for the specified pet by its unique ID.
	//
	// Corresponds with GET /v1/pets/{petId} (the `ShowPetById` operationId).
	ShowPetById(ctx context.Context, petId ID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListUsers List all users
	//
	// Retrieve a list (paged) of registered users.
	//
	// Corresponds with GET /v1/users (the `ListUsers` operationId).
	ListUsers(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateUserWithBody Create a user
	//
	// Register a new user at an admin level. Typically requires elevated permissions.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/users (the `CreateUser` operationId).
	CreateUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateUser Create a user
	//
	// Register a new user at an admin level. Typically requires elevated permissions.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/users (the `CreateUser` operationId).
	CreateUser(ctx context.Context, body CreateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteUser Delete a user
	//
	// Remove the user record (soft or hard delete).
	//
	// SECURITY (SEC-0027 / BOLA, CWE-639): object-scoped route keyed on userId.
	// The generated wrapper authenticates only (BearerAuth presence); it does
	// NOT verify the caller owns {userId}. The ServerInterface implementation
	// MUST enforce object-level ownership (securex.RequireOwnership, JWT
	// sub == userId) — or any authenticated user can delete any other user.
	//
	// Corresponds with DELETE /v1/users/{userId} (the `DeleteUser` operationId).
	DeleteUser(ctx context.Context, userId ID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetUserById Get a specific user
	//
	// Retrieve data for a user by their ID.
	//
	// SECURITY (SEC-0027 / BOLA, CWE-639): this is an object-scoped route keyed
	// on userId. The generated wrapper performs authentication only (BearerAuth
	// presence); it does NOT verify that the caller owns {userId}. The
	// ServerInterface implementation MUST enforce object-level ownership — e.g.
	// gate the route with securex.RequireOwnership (JWT sub == userId) — or an
	// IDOR / horizontal privilege escalation results.
	//
	// Corresponds with GET /v1/users/{userId} (the `GetUserById` operationId).
	GetUserById(ctx context.Context, userId ID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateUserWithBody Update a specific user
	//
	// Perform a partial update (e.g., roles, password) for an existing user.
	//
	// SECURITY (SEC-0027 / BOLA, CWE-639 + CWE-862): object-scoped route keyed
	// on userId that also exposes roles/password (vertical privilege-escalation
	// surface). The generated wrapper authenticates only (BearerAuth presence);
	// it does NOT verify the caller owns {userId} nor that role changes are
	// authorized. The ServerInterface implementation MUST enforce object-level
	// ownership (securex.RequireOwnership, JWT sub == userId) AND a role-change
	// authorization check, or IDOR / privilege escalation results.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /v1/users/{userId} (the `UpdateUser` operationId).
	UpdateUserWithBody(ctx context.Context, userId ID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateUser Update a specific user
	//
	// Perform a partial update (e.g., roles, password) for an existing user.
	//
	// SECURITY (SEC-0027 / BOLA, CWE-639 + CWE-862): object-scoped route keyed
	// on userId that also exposes roles/password (vertical privilege-escalation
	// surface). The generated wrapper authenticates only (BearerAuth presence);
	// it does NOT verify the caller owns {userId} nor that role changes are
	// authorized. The ServerInterface implementation MUST enforce object-level
	// ownership (securex.RequireOwnership, JWT sub == userId) AND a role-change
	// authorization check, or IDOR / privilege escalation results.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /v1/users/{userId} (the `UpdateUser` operationId).
	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 User login
	//
	// Log in with username/password to obtain an access token (JWT or OAuth2).
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/auth/login (the `LoginUser` operationId).
	LoginUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*LoginUserResponse, error)

	// LoginUserWithResponse User login
	//
	// Log in with username/password to obtain an access token (JWT or OAuth2).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/auth/login (the `LoginUser` operationId).
	LoginUserWithResponse(ctx context.Context, body LoginUserJSONRequestBody, reqEditors ...RequestEditorFn) (*LoginUserResponse, error)

	// LogoutUserWithResponse Logout user
	//
	// Invalidate the current token or session.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/auth/logout (the `LogoutUser` operationId).
	LogoutUserWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*LogoutUserResponse, error)

	// GetCurrentUserWithResponse Get current user info
	//
	// Retrieve the user profile data (including roles/claims) from the current session/token.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/auth/me (the `GetCurrentUser` operationId).
	GetCurrentUserWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetCurrentUserResponse, error)

	// RefreshTokenWithBodyWithResponse Refresh user token
	//
	// Obtain a new token using a valid refresh token.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/auth/refresh (the `RefreshToken` operationId).
	RefreshTokenWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RefreshTokenResponse, error)

	// RefreshTokenWithResponse Refresh user token
	//
	// Obtain a new token using a valid refresh token.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/auth/refresh (the `RefreshToken` operationId).
	RefreshTokenWithResponse(ctx context.Context, body RefreshTokenJSONRequestBody, reqEditors ...RequestEditorFn) (*RefreshTokenResponse, error)

	// RegisterUserWithBodyWithResponse User registration
	//
	// Register a new user with username/password.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/auth/register (the `RegisterUser` operationId).
	RegisterUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RegisterUserResponse, error)

	// RegisterUserWithResponse User registration
	//
	// Register a new user with username/password.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/auth/register (the `RegisterUser` operationId).
	RegisterUserWithResponse(ctx context.Context, body RegisterUserJSONRequestBody, reqEditors ...RequestEditorFn) (*RegisterUserResponse, error)

	// EchoWithBodyWithResponse Echo
	//
	// Echo the provided message.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/echo (the `Echo` operationId).
	EchoWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*EchoResponse, error)

	// EchoWithResponse Echo
	//
	// Echo the provided message.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/echo (the `Echo` operationId).
	EchoWithResponse(ctx context.Context, body EchoJSONRequestBody, reqEditors ...RequestEditorFn) (*EchoResponse, error)

	// ListPetsWithResponse List all pets
	//
	// Retrieve a list (paged) of pets from the server.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/pets (the `ListPets` operationId).
	ListPetsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListPetsResponse, error)

	// CreatePetWithBodyWithResponse Create a pet
	//
	// Create a new pet in the server’s database.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/pets (the `CreatePet` operationId).
	CreatePetWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreatePetResponse, error)

	// CreatePetWithResponse Create a pet
	//
	// Create a new pet in the server’s database.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/pets (the `CreatePet` operationId).
	CreatePetWithResponse(ctx context.Context, body CreatePetJSONRequestBody, reqEditors ...RequestEditorFn) (*CreatePetResponse, error)

	// ShowPetByIdWithResponse Show a specific pet
	//
	// Retrieve data for the specified pet by its unique ID.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/pets/{petId} (the `ShowPetById` operationId).
	ShowPetByIdWithResponse(ctx context.Context, petId ID, reqEditors ...RequestEditorFn) (*ShowPetByIdResponse, error)

	// ListUsersWithResponse List all users
	//
	// Retrieve a list (paged) of registered users.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/users (the `ListUsers` operationId).
	ListUsersWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListUsersResponse, error)

	// CreateUserWithBodyWithResponse Create a user
	//
	// Register a new user at an admin level. Typically requires elevated permissions.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/users (the `CreateUser` operationId).
	CreateUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateUserResponse, error)

	// CreateUserWithResponse Create a user
	//
	// Register a new user at an admin level. Typically requires elevated permissions.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/users (the `CreateUser` operationId).
	CreateUserWithResponse(ctx context.Context, body CreateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateUserResponse, error)

	// DeleteUserWithResponse Delete a user
	//
	// Remove the user record (soft or hard delete).
	//
	// SECURITY (SEC-0027 / BOLA, CWE-639): object-scoped route keyed on userId.
	// The generated wrapper authenticates only (BearerAuth presence); it does
	// NOT verify the caller owns {userId}. The ServerInterface implementation
	// MUST enforce object-level ownership (securex.RequireOwnership, JWT
	// sub == userId) — or any authenticated user can delete any other user.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/users/{userId} (the `DeleteUser` operationId).
	DeleteUserWithResponse(ctx context.Context, userId ID, reqEditors ...RequestEditorFn) (*DeleteUserResponse, error)

	// GetUserByIdWithResponse Get a specific user
	//
	// Retrieve data for a user by their ID.
	//
	// SECURITY (SEC-0027 / BOLA, CWE-639): this is an object-scoped route keyed
	// on userId. The generated wrapper performs authentication only (BearerAuth
	// presence); it does NOT verify that the caller owns {userId}. The
	// ServerInterface implementation MUST enforce object-level ownership — e.g.
	// gate the route with securex.RequireOwnership (JWT sub == userId) — or an
	// IDOR / horizontal privilege escalation results.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/users/{userId} (the `GetUserById` operationId).
	GetUserByIdWithResponse(ctx context.Context, userId ID, reqEditors ...RequestEditorFn) (*GetUserByIdResponse, error)

	// UpdateUserWithBodyWithResponse Update a specific user
	//
	// Perform a partial update (e.g., roles, password) for an existing user.
	//
	// SECURITY (SEC-0027 / BOLA, CWE-639 + CWE-862): object-scoped route keyed
	// on userId that also exposes roles/password (vertical privilege-escalation
	// surface). The generated wrapper authenticates only (BearerAuth presence);
	// it does NOT verify the caller owns {userId} nor that role changes are
	// authorized. The ServerInterface implementation MUST enforce object-level
	// ownership (securex.RequireOwnership, JWT sub == userId) AND a role-change
	// authorization check, or IDOR / privilege escalation results.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /v1/users/{userId} (the `UpdateUser` operationId).
	UpdateUserWithBodyWithResponse(ctx context.Context, userId ID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateUserResponse, error)

	// UpdateUserWithResponse Update a specific user
	//
	// Perform a partial update (e.g., roles, password) for an existing user.
	//
	// SECURITY (SEC-0027 / BOLA, CWE-639 + CWE-862): object-scoped route keyed
	// on userId that also exposes roles/password (vertical privilege-escalation
	// surface). The generated wrapper authenticates only (BearerAuth presence);
	// it does NOT verify the caller owns {userId} nor that role changes are
	// authorized. The ServerInterface implementation MUST enforce object-level
	// ownership (securex.RequireOwnership, JWT sub == userId) AND a role-change
	// authorization check, or IDOR / privilege escalation results.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /v1/users/{userId} (the `UpdateUser` operationId).
	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 the response for an HTTP 201 `application/json` response
	JSON201 *Pet
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON403 the response for an HTTP 403 `application/json` response
	JSON403 *Forbidden
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers201 the parsed response headers for an HTTP 201 response
	Headers201 *CreatePetResponse201Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *CreatePetResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *CreatePetResponse401Headers
	// Headers403 the parsed response headers for an HTTP 403 response
	Headers403 *CreatePetResponse403Headers
	// Headers404 the parsed response headers for an HTTP 404 response
	Headers404 *CreatePetResponse404Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *CreatePetResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *CreatePetResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *CreatePetResponseDefaultHeaders
}

type CreatePetResponse201Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreatePetResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreatePetResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreatePetResponse403Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreatePetResponse404Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreatePetResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreatePetResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreatePetResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreateUserJSONRequestBody = Registration

type CreateUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *User
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON403 the response for an HTTP 403 `application/json` response
	JSON403 *Forbidden
	// JSON409 the response for an HTTP 409 `application/json` response
	JSON409 *Conflict
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers201 the parsed response headers for an HTTP 201 response
	Headers201 *CreateUserResponse201Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *CreateUserResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *CreateUserResponse401Headers
	// Headers403 the parsed response headers for an HTTP 403 response
	Headers403 *CreateUserResponse403Headers
	// Headers409 the parsed response headers for an HTTP 409 response
	Headers409 *CreateUserResponse409Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *CreateUserResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *CreateUserResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *CreateUserResponseDefaultHeaders
}

type CreateUserResponse201Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreateUserResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreateUserResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreateUserResponse403Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreateUserResponse409Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreateUserResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreateUserResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type CreateUserResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type DeleteUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON403 the response for an HTTP 403 `application/json` response
	JSON403 *Forbidden
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers204 the parsed response headers for an HTTP 204 response
	Headers204 *DeleteUserResponse204Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *DeleteUserResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *DeleteUserResponse401Headers
	// Headers403 the parsed response headers for an HTTP 403 response
	Headers403 *DeleteUserResponse403Headers
	// Headers404 the parsed response headers for an HTTP 404 response
	Headers404 *DeleteUserResponse404Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *DeleteUserResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *DeleteUserResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *DeleteUserResponseDefaultHeaders
}

type DeleteUserResponse204Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type DeleteUserResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type DeleteUserResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type DeleteUserResponse403Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type DeleteUserResponse404Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type DeleteUserResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type DeleteUserResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type DeleteUserResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type EchoJSONRequestBody = EchoReq

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

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

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

type EchoResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *EchoResp
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *EchoResponse200Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *EchoResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *EchoResponse401Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *EchoResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *EchoResponse500Headers
}

type EchoResponse200Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type EchoResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type EchoResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type EchoResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type EchoResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

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

	// Id id for the Record
	//
	// Examples: 123e4567-e89b-12d3-a456-426614174000
	Id *ID `json:"id,omitempty"`

	// Message Error message
	//
	// Examples: Something went wrong.
	Message string `json:"message"`
}

type Forbidden = Error

type GetCurrentUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *User
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON403 the response for an HTTP 403 `application/json` response
	JSON403 *Forbidden
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *GetCurrentUserResponse200Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *GetCurrentUserResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *GetCurrentUserResponse401Headers
	// Headers403 the parsed response headers for an HTTP 403 response
	Headers403 *GetCurrentUserResponse403Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *GetCurrentUserResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *GetCurrentUserResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *GetCurrentUserResponseDefaultHeaders
}

type GetCurrentUserResponse200Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetCurrentUserResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetCurrentUserResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetCurrentUserResponse403Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetCurrentUserResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetCurrentUserResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetCurrentUserResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetUserByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *User
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON403 the response for an HTTP 403 `application/json` response
	JSON403 *Forbidden
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *GetUserByIdResponse200Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *GetUserByIdResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *GetUserByIdResponse401Headers
	// Headers403 the parsed response headers for an HTTP 403 response
	Headers403 *GetUserByIdResponse403Headers
	// Headers404 the parsed response headers for an HTTP 404 response
	Headers404 *GetUserByIdResponse404Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *GetUserByIdResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *GetUserByIdResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *GetUserByIdResponseDefaultHeaders
}

type GetUserByIdResponse200Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetUserByIdResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetUserByIdResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetUserByIdResponse403Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetUserByIdResponse404Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetUserByIdResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetUserByIdResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type GetUserByIdResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

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

type ID = uuid.UUID

type InternalServerError = Error

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type ListPetsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *[]Pet
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON403 the response for an HTTP 403 `application/json` response
	JSON403 *Forbidden
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *ListPetsResponse200Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *ListPetsResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *ListPetsResponse401Headers
	// Headers403 the parsed response headers for an HTTP 403 response
	Headers403 *ListPetsResponse403Headers
	// Headers404 the parsed response headers for an HTTP 404 response
	Headers404 *ListPetsResponse404Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *ListPetsResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *ListPetsResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *ListPetsResponseDefaultHeaders
}

type ListPetsResponse200Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListPetsResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListPetsResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListPetsResponse403Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListPetsResponse404Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListPetsResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListPetsResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListPetsResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListUsersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *[]User
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON403 the response for an HTTP 403 `application/json` response
	JSON403 *Forbidden
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *ListUsersResponse200Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *ListUsersResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *ListUsersResponse401Headers
	// Headers403 the parsed response headers for an HTTP 403 response
	Headers403 *ListUsersResponse403Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *ListUsersResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *ListUsersResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *ListUsersResponseDefaultHeaders
}

type ListUsersResponse200Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListUsersResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListUsersResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListUsersResponse403Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListUsersResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListUsersResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type ListUsersResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type Login struct {
	// Password Password for authentication
	//
	// Examples: My Password is a Passphrase 123!
	Password Password `` /* 137-byte string literal not displayed */

	// Username Username for authentication
	//
	// Examples: username123
	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 the response for an HTTP 200 `application/json` response
	JSON200 *Token
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *LoginUserResponse200Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *LoginUserResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *LoginUserResponse401Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *LoginUserResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *LoginUserResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *LoginUserResponseDefaultHeaders
}

type LoginUserResponse200Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LoginUserResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LoginUserResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LoginUserResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LoginUserResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LoginUserResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LogoutUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *struct {
		// Message Examples: Logout successful
		Message *string `json:"message,omitempty"`
	}
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *LogoutUserResponse200Headers
	// Headers204 the parsed response headers for an HTTP 204 response
	Headers204 *LogoutUserResponse204Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *LogoutUserResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *LogoutUserResponse401Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *LogoutUserResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *LogoutUserResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *LogoutUserResponseDefaultHeaders
}

type LogoutUserResponse200Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LogoutUserResponse204Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LogoutUserResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LogoutUserResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LogoutUserResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LogoutUserResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type LogoutUserResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type MiddlewareFunc func(http.Handler) http.Handler

type NotFound = Error

type Password = string

type Pet struct {
	// Id id for the Record
	//
	// Examples: 123e4567-e89b-12d3-a456-426614174000
	Id *ID `json:"id,omitempty"`

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

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

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

type RefreshTokenJSONRequestBody RefreshTokenJSONBody

type RefreshTokenResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *Token
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *RefreshTokenResponse200Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *RefreshTokenResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *RefreshTokenResponse401Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *RefreshTokenResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *RefreshTokenResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *RefreshTokenResponseDefaultHeaders
}

type RefreshTokenResponse200Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RefreshTokenResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RefreshTokenResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RefreshTokenResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RefreshTokenResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RefreshTokenResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RegisterUserJSONRequestBody = Registration

type RegisterUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *User
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON409 the response for an HTTP 409 `application/json` response
	JSON409 *Conflict
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers201 the parsed response headers for an HTTP 201 response
	Headers201 *RegisterUserResponse201Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *RegisterUserResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *RegisterUserResponse401Headers
	// Headers409 the parsed response headers for an HTTP 409 response
	Headers409 *RegisterUserResponse409Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *RegisterUserResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *RegisterUserResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *RegisterUserResponseDefaultHeaders
}

type RegisterUserResponse201Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RegisterUserResponse400Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RegisterUserResponse401Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RegisterUserResponse409Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RegisterUserResponse429Headers struct {
	RetryAfter          *int32
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RegisterUserResponse500Headers struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type RegisterUserResponseDefaultHeaders struct {
	XRateLimitLimit     *int32
	XRateLimitRemaining *int32
	XRateLimitReset     *time.Time
}

type Registration struct {
	// Password Password for authentication
	//
	// Examples: My Password is a Passphrase 123!
	Password Password `` /* 137-byte string literal not displayed */

	// Username Username for authentication
	//
	// Examples: username123
	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 RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

type Role string

type ServeMux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	http.Handler
}

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

type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type ShowPetByIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *Pet
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *Pet
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// JSON403 the response for an HTTP 403 `application/json` response
	JSON403 *Forbidden
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
	// JSON429 the response for an HTTP 429 `application/json` response
	JSON429 *TooManyRequests
	// JSON500 the response for an HTTP 500 `application/json` response
	JSON500 *InternalServerError
	// JSONDefault the response for an HTTP default `application/json` response
	JSONDefault *UnexpectedError
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *ShowPetByIdResponse200Headers
	// Headers201 the parsed response headers for an HTTP 201 response
	Headers201 *ShowPetByIdResponse201Headers
	// Headers400 the parsed response headers for an HTTP 400 response
	Headers400 *ShowPetByIdResponse400Headers
	// Headers401 the parsed response headers for an HTTP 401 response
	Headers401 *ShowPetByIdResponse401Headers
	// Headers403 the parsed response headers for an HTTP 403 response
	Headers403 *ShowPetByIdResponse403Headers
	// Headers404 the parsed response headers for an HTTP 404 response
	Headers404 *ShowPetByIdResponse404Headers
	// Headers429 the parsed response headers for an HTTP 429 response
	Headers429 *ShowPetByIdResponse429Headers
	// Headers500 the parsed response headers for an HTTP 500 response
	Headers500 *ShowPetByIdResponse500Headers
	// HeadersDefault the parsed response headers for an HTTP default response
	HeadersDefault *ShowPetByIdResponseDefaultHeaders
}