@kubb/plugin-client 4.8.0 → 4.9.0

package/src/components/ClassClient.tsx

@@ -0,0 +1,235 @@
+import { buildJSDoc, URLPath } from '@kubb/core/utils'
+import type { Operation } from '@kubb/oas'
+import type { OperationSchemas } from '@kubb/plugin-oas'
+import { getComments } from '@kubb/plugin-oas/utils'
+import { File, FunctionParams } from '@kubb/react-fabric'
+import type { KubbNode } from '@kubb/react-fabric/types'
+import type { PluginClient } from '../types.ts'
+
+import { Client } from './Client.tsx'
+
+type Props = {
+  /**
+   * Name of the class
+   */
+  name: string
+  isExportable?: boolean
+  isIndexable?: boolean
+  operations: Array<{
+    operation: Operation
+    name: string
+    typeSchemas: OperationSchemas
+    zodSchemas: OperationSchemas | undefined
+  }>
+  baseURL: string | undefined
+  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
+  paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
+  paramsType: PluginClient['resolvedOptions']['pathParamsType']
+  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
+  parser: PluginClient['resolvedOptions']['parser'] | undefined
+  children?: KubbNode
+}
+
+type GenerateMethodProps = {
+  operation: Operation
+  name: string
+  typeSchemas: OperationSchemas
+  zodSchemas: OperationSchemas | undefined
+  baseURL: string | undefined
+  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
+  parser: PluginClient['resolvedOptions']['parser'] | undefined
+  paramsType: PluginClient['resolvedOptions']['paramsType']
+  paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
+  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
+}
+
+function buildHeaders(contentType: string, hasHeaderParams: boolean): Array<string> {
+  return [
+    contentType !== 'application/json' && contentType !== 'multipart/form-data' ? `'Content-Type': '${contentType}'` : undefined,
+    hasHeaderParams ? '...headers' : undefined,
+  ].filter(Boolean) as Array<string>
+}
+
+function buildGenerics(typeSchemas: OperationSchemas): Array<string> {
+  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
+  return [typeSchemas.response.name, TError, typeSchemas.request?.name || 'unknown'].filter(Boolean)
+}
+
+function buildClientParams({
+  operation,
+  path,
+  baseURL,
+  typeSchemas,
+  isFormData,
+  headers,
+}: {
+  operation: Operation
+  path: URLPath
+  baseURL: string | undefined
+  typeSchemas: OperationSchemas
+  isFormData: boolean
+  headers: Array<string>
+}) {
+  return FunctionParams.factory({
+    config: {
+      mode: 'object',
+      children: {
+        method: {
+          value: JSON.stringify(operation.method.toUpperCase()),
+        },
+        url: {
+          value: path.template,
+        },
+        baseURL: baseURL
+          ? {
+              value: JSON.stringify(baseURL),
+            }
+          : undefined,
+        params: typeSchemas.queryParams?.name ? {} : undefined,
+        data: typeSchemas.request?.name
+          ? {
+              value: isFormData ? 'formData as FormData' : 'requestData',
+            }
+          : undefined,
+        requestConfig: {
+          mode: 'inlineSpread',
+        },
+        headers: headers.length
+          ? {
+              value: `{ ${headers.join(', ')}, ...requestConfig.headers }`,
+            }
+          : undefined,
+      },
+    },
+  })
+}
+
+function buildRequestDataLine({
+  parser,
+  zodSchemas,
+  typeSchemas,
+}: {
+  parser: PluginClient['resolvedOptions']['parser'] | undefined
+  zodSchemas: OperationSchemas | undefined
+  typeSchemas: OperationSchemas
+}): string {
+  if (parser === 'zod' && zodSchemas?.request?.name) {
+    return `const requestData = ${zodSchemas.request.name}.parse(data)`
+  }
+  if (typeSchemas?.request?.name) {
+    return 'const requestData = data'
+  }
+  return ''
+}
+
+function buildFormDataLine(isFormData: boolean, hasRequest: boolean): string {
+  return isFormData && hasRequest ? 'const formData = buildFormData(requestData)' : ''
+}
+
+function buildReturnStatement({
+  dataReturnType,
+  parser,
+  zodSchemas,
+}: {
+  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
+  parser: PluginClient['resolvedOptions']['parser'] | undefined
+  zodSchemas: OperationSchemas | undefined
+}): string {
+  if (dataReturnType === 'full' && parser === 'zod' && zodSchemas) {
+    return `return {...res, data: ${zodSchemas.response.name}.parse(res.data)}`
+  }
+  if (dataReturnType === 'data' && parser === 'zod' && zodSchemas) {
+    return `return ${zodSchemas.response.name}.parse(res.data)`
+  }
+  if (dataReturnType === 'full' && parser === 'client') {
+    return 'return res'
+  }
+  return 'return res.data'
+}
+
+function generateMethod({
+  operation,
+  name,
+  typeSchemas,
+  zodSchemas,
+  baseURL,
+  dataReturnType,
+  parser,
+  paramsType,
+  paramsCasing,
+  pathParamsType,
+}: GenerateMethodProps): string {
+  const path = new URLPath(operation.path, { casing: paramsCasing })
+  const contentType = operation.getContentType()
+  const isFormData = contentType === 'multipart/form-data'
+  const headers = buildHeaders(contentType, !!typeSchemas.headerParams?.name)
+  const generics = buildGenerics(typeSchemas)
+  const params = ClassClient.getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas, isConfigurable: true })
+  const clientParams = buildClientParams({ operation, path, baseURL, typeSchemas, isFormData, headers })
+  const jsdoc = buildJSDoc(getComments(operation))
+
+  const requestDataLine = buildRequestDataLine({ parser, zodSchemas, typeSchemas })
+  const formDataLine = buildFormDataLine(isFormData, !!typeSchemas?.request?.name)
+  const returnStatement = buildReturnStatement({ dataReturnType, parser, zodSchemas })
+
+  const methodBody = [
+    'const { client: request = this.#client, ...requestConfig } = config',
+    '',
+    requestDataLine,
+    formDataLine,
+    `const res = await request<${generics.join(', ')}>(${clientParams.toCall()})`,
+    returnStatement,
+  ]
+    .filter(Boolean)
+    .map((line) => `    ${line}`)
+    .join('\n')
+
+  return `${jsdoc}async ${name}(${params.toConstructor()}) {\n${methodBody}\n  }`
+}
+
+export function ClassClient({
+  name,
+  isExportable = true,
+  isIndexable = true,
+  operations,
+  baseURL,
+  dataReturnType,
+  parser,
+  paramsType,
+  paramsCasing,
+  pathParamsType,
+  children,
+}: Props): KubbNode {
+  const methods = operations.map(({ operation, name: methodName, typeSchemas, zodSchemas }) =>
+    generateMethod({
+      operation,
+      name: methodName,
+      typeSchemas,
+      zodSchemas,
+      baseURL,
+      dataReturnType,
+      parser,
+      paramsType,
+      paramsCasing,
+      pathParamsType,
+    }),
+  )
+
+  const classCode = `export class ${name} {
+  #client: typeof fetch
+
+  constructor(config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    this.#client = config.client || fetch
+  }
+
+${methods.join('\n\n')}
+}`
+
+  return (
+    <File.Source name={name} isExportable={isExportable} isIndexable={isIndexable}>
+      {classCode}
+      {children}
+    </File.Source>
+  )
+}
+ClassClient.getParams = Client.getParams

package/src/components/Client.tsx

@@ -212,8 +212,9 @@ export function Client({
         {isConfigurable ? 'const { client: request = fetch, ...requestConfig } = config' : ''}
         <br />
         <br />
-        {parser === 'zod' && zodSchemas?.request?.name && `const requestData = ${zodSchemas.request.name}.parse(data)`}
-        {parser === 'client' && typeSchemas?.request?.name && 'const requestData = data'}
+        {parser === 'zod' && zodSchemas?.request?.name
+          ? `const requestData = ${zodSchemas.request.name}.parse(data)`
+          : typeSchemas?.request?.name && 'const requestData = data'}
         <br />
         {isFormData && typeSchemas?.request?.name && 'const formData = buildFormData(requestData)'}
         <br />

package/src/components/index.ts

@@ -1,3 +1,4 @@
+export { ClassClient } from './ClassClient.tsx'
 export { Client } from './Client.tsx'
 export { Operations } from './Operations.tsx'
 export { Url } from './Url.tsx'

package/src/generators/__snapshots__/Pet.ts

@@ -0,0 +1,186 @@
+/**
+ * Generated by Kubb (https://kubb.dev/).
+ * Do not edit manually.
+ */
+import type { RequestConfig, ResponseErrorConfig } from './test/.kubb/fetch'
+import type {
+  UpdatePetMutationRequest,
+  UpdatePetMutationResponse,
+  UpdatePet400,
+  UpdatePet404,
+  UpdatePet405,
+  AddPetMutationRequest,
+  AddPetMutationResponse,
+  AddPet405,
+  FindPetsByStatusQueryResponse,
+  FindPetsByStatusQueryParams,
+  FindPetsByStatus400,
+  FindPetsByTagsQueryResponse,
+  FindPetsByTagsQueryParams,
+  FindPetsByTags400,
+  GetPetByIdQueryResponse,
+  GetPetByIdPathParams,
+  GetPetById400,
+  GetPetById404,
+  UpdatePetWithFormMutationResponse,
+  UpdatePetWithFormPathParams,
+  UpdatePetWithFormQueryParams,
+  UpdatePetWithForm405,
+  DeletePetMutationResponse,
+  DeletePetPathParams,
+  DeletePetHeaderParams,
+  DeletePet400,
+  UploadFileMutationRequest,
+  UploadFileMutationResponse,
+  UploadFilePathParams,
+  UploadFileQueryParams,
+} from './findByTags'
+import { buildFormData } from './test/.kubb/config'
+import { fetch } from './test/.kubb/fetch'
+
+export class Pet {
+  #client: typeof fetch
+
+  constructor(config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    this.#client = config.client || fetch
+  }
+
+  /**
+   * @description Update an existing pet by Id
+   * @summary Update an existing pet
+   * {@link /pet}
+   */
+  async updatePet(data: UpdatePetMutationRequest, config: Partial<RequestConfig<UpdatePetMutationRequest>> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const requestData = data
+    const res = await request<UpdatePetMutationResponse, ResponseErrorConfig<UpdatePet400 | UpdatePet404 | UpdatePet405>, UpdatePetMutationRequest>({
+      method: 'PUT',
+      url: `/pet`,
+      data: requestData,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description Add a new pet to the store
+   * @summary Add a new pet to the store
+   * {@link /pet}
+   */
+  async addPet(data: AddPetMutationRequest, config: Partial<RequestConfig<AddPetMutationRequest>> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const requestData = data
+    const res = await request<AddPetMutationResponse, ResponseErrorConfig<AddPet405>, AddPetMutationRequest>({
+      method: 'POST',
+      url: `/pet`,
+      data: requestData,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description Multiple status values can be provided with comma separated strings
+   * @summary Finds Pets by status
+   * {@link /pet/findByStatus}
+   */
+  async findPetsByStatus(params?: FindPetsByStatusQueryParams, config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<FindPetsByStatusQueryResponse, ResponseErrorConfig<FindPetsByStatus400>, unknown>({
+      method: 'GET',
+      url: `/pet/findByStatus`,
+      params,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+   * @summary Finds Pets by tags
+   * {@link /pet/findByTags}
+   */
+  async findPetsByTags(params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<FindPetsByTagsQueryResponse, ResponseErrorConfig<FindPetsByTags400>, unknown>({
+      method: 'GET',
+      url: `/pet/findByTags`,
+      params,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description Returns a single pet
+   * @summary Find pet by ID
+   * {@link /pet/:petId}
+   */
+  async getPetById(petId: GetPetByIdPathParams['petId'], config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<GetPetByIdQueryResponse, ResponseErrorConfig<GetPetById400 | GetPetById404>, unknown>({
+      method: 'GET',
+      url: `/pet/${petId}`,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @summary Updates a pet in the store with form data
+   * {@link /pet/:petId}
+   */
+  async updatePetWithForm(
+    petId: UpdatePetWithFormPathParams['petId'],
+    params?: UpdatePetWithFormQueryParams,
+    config: Partial<RequestConfig> & { client?: typeof fetch } = {},
+  ) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<UpdatePetWithFormMutationResponse, ResponseErrorConfig<UpdatePetWithForm405>, unknown>({
+      method: 'POST',
+      url: `/pet/${petId}`,
+      params,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description delete a pet
+   * @summary Deletes a pet
+   * {@link /pet/:petId}
+   */
+  async deletePet(petId: DeletePetPathParams['petId'], headers?: DeletePetHeaderParams, config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<DeletePetMutationResponse, ResponseErrorConfig<DeletePet400>, unknown>({
+      method: 'DELETE',
+      url: `/pet/${petId}`,
+      ...requestConfig,
+      headers: { ...headers, ...requestConfig.headers },
+    })
+    return res.data
+  }
+
+  /**
+   * @summary uploads an image
+   * {@link /pet/:petId/uploadImage}
+   */
+  async uploadFile(
+    petId: UploadFilePathParams['petId'],
+    data: UploadFileMutationRequest,
+    params?: UploadFileQueryParams,
+    config: Partial<RequestConfig<UploadFileMutationRequest>> & { client?: typeof fetch } = {},
+  ) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const requestData = data
+    const formData = buildFormData(requestData)
+    const res = await request<UploadFileMutationResponse, ResponseErrorConfig<Error>, UploadFileMutationRequest>({
+      method: 'POST',
+      url: `/pet/${petId}/uploadImage`,
+      params,
+      data: formData as FormData,
+      ...requestConfig,
+    })
+    return res.data
+  }
+}

package/src/generators/__snapshots__/Store.ts

@@ -0,0 +1,109 @@
+/**
+ * Generated by Kubb (https://kubb.dev/).
+ * Do not edit manually.
+ */
+import type { RequestConfig, ResponseErrorConfig } from './test/.kubb/fetch'
+import type {
+  GetInventoryQueryResponse,
+  PlaceOrderMutationRequest,
+  PlaceOrderMutationResponse,
+  PlaceOrder405,
+  PlaceOrderPatchMutationRequest,
+  PlaceOrderPatchMutationResponse,
+  PlaceOrderPatch405,
+  GetOrderByIdQueryResponse,
+  GetOrderByIdPathParams,
+  GetOrderById400,
+  GetOrderById404,
+  DeleteOrderMutationResponse,
+  DeleteOrderPathParams,
+  DeleteOrder400,
+  DeleteOrder404,
+} from './findByTags'
+import { fetch } from './test/.kubb/fetch'
+
+export class Store {
+  #client: typeof fetch
+
+  constructor(config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    this.#client = config.client || fetch
+  }
+
+  /**
+   * @description Returns a map of status codes to quantities
+   * @summary Returns pet inventories by status
+   * {@link /store/inventory}
+   */
+  async getInventory(config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<GetInventoryQueryResponse, ResponseErrorConfig<Error>, unknown>({ method: 'GET', url: `/store/inventory`, ...requestConfig })
+    return res.data
+  }
+
+  /**
+   * @description Place a new order in the store
+   * @summary Place an order for a pet
+   * {@link /store/order}
+   */
+  async placeOrder(data?: PlaceOrderMutationRequest, config: Partial<RequestConfig<PlaceOrderMutationRequest>> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const requestData = data
+    const res = await request<PlaceOrderMutationResponse, ResponseErrorConfig<PlaceOrder405>, PlaceOrderMutationRequest>({
+      method: 'POST',
+      url: `/store/order`,
+      data: requestData,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description Place a new order in the store with patch
+   * @summary Place an order for a pet with patch
+   * {@link /store/order}
+   */
+  async placeOrderPatch(
+    data?: PlaceOrderPatchMutationRequest,
+    config: Partial<RequestConfig<PlaceOrderPatchMutationRequest>> & { client?: typeof fetch } = {},
+  ) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const requestData = data
+    const res = await request<PlaceOrderPatchMutationResponse, ResponseErrorConfig<PlaceOrderPatch405>, PlaceOrderPatchMutationRequest>({
+      method: 'PATCH',
+      url: `/store/order`,
+      data: requestData,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions.
+   * @summary Find purchase order by ID
+   * {@link /store/order/:orderId}
+   */
+  async getOrderById(orderId: GetOrderByIdPathParams['orderId'], config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<GetOrderByIdQueryResponse, ResponseErrorConfig<GetOrderById400 | GetOrderById404>, unknown>({
+      method: 'GET',
+      url: `/store/order/${orderId}`,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+   * @summary Delete purchase order by ID
+   * {@link /store/order/:orderId}
+   */
+  async deleteOrder(orderId: DeleteOrderPathParams['orderId'], config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<DeleteOrderMutationResponse, ResponseErrorConfig<DeleteOrder400 | DeleteOrder404>, unknown>({
+      method: 'DELETE',
+      url: `/store/order/${orderId}`,
+      ...requestConfig,
+    })
+    return res.data
+  }
+}

package/src/generators/__snapshots__/User.ts

@@ -0,0 +1,147 @@
+/**
+ * Generated by Kubb (https://kubb.dev/).
+ * Do not edit manually.
+ */
+import type { RequestConfig, ResponseErrorConfig } from './test/.kubb/fetch'
+import type {
+  CreateUserMutationRequest,
+  CreateUserMutationResponse,
+  CreateUsersWithListInputMutationRequest,
+  CreateUsersWithListInputMutationResponse,
+  LoginUserQueryResponse,
+  LoginUserQueryParams,
+  LoginUser400,
+  LogoutUserQueryResponse,
+  GetUserByNameQueryResponse,
+  GetUserByNamePathParams,
+  GetUserByName400,
+  GetUserByName404,
+  UpdateUserMutationRequest,
+  UpdateUserMutationResponse,
+  UpdateUserPathParams,
+  DeleteUserMutationResponse,
+  DeleteUserPathParams,
+  DeleteUser400,
+  DeleteUser404,
+} from './findByTags'
+import { fetch } from './test/.kubb/fetch'
+
+export class User {
+  #client: typeof fetch
+
+  constructor(config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    this.#client = config.client || fetch
+  }
+
+  /**
+   * @description This can only be done by the logged in user.
+   * @summary Create user
+   * {@link /user}
+   */
+  async createUser(data?: CreateUserMutationRequest, config: Partial<RequestConfig<CreateUserMutationRequest>> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const requestData = data
+    const res = await request<CreateUserMutationResponse, ResponseErrorConfig<Error>, CreateUserMutationRequest>({
+      method: 'POST',
+      url: `/user`,
+      data: requestData,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description Creates list of users with given input array
+   * @summary Creates list of users with given input array
+   * {@link /user/createWithList}
+   */
+  async createUsersWithListInput(
+    data?: CreateUsersWithListInputMutationRequest,
+    config: Partial<RequestConfig<CreateUsersWithListInputMutationRequest>> & { client?: typeof fetch } = {},
+  ) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const requestData = data
+    const res = await request<CreateUsersWithListInputMutationResponse, ResponseErrorConfig<Error>, CreateUsersWithListInputMutationRequest>({
+      method: 'POST',
+      url: `/user/createWithList`,
+      data: requestData,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @summary Logs user into the system
+   * {@link /user/login}
+   */
+  async loginUser(params?: LoginUserQueryParams, config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<LoginUserQueryResponse, ResponseErrorConfig<LoginUser400>, unknown>({
+      method: 'GET',
+      url: `/user/login`,
+      params,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @summary Logs out current logged in user session
+   * {@link /user/logout}
+   */
+  async logoutUser(config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<LogoutUserQueryResponse, ResponseErrorConfig<Error>, unknown>({ method: 'GET', url: `/user/logout`, ...requestConfig })
+    return res.data
+  }
+
+  /**
+   * @summary Get user by user name
+   * {@link /user/:username}
+   */
+  async getUserByName(username: GetUserByNamePathParams['username'], config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<GetUserByNameQueryResponse, ResponseErrorConfig<GetUserByName400 | GetUserByName404>, unknown>({
+      method: 'GET',
+      url: `/user/${username}`,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description This can only be done by the logged in user.
+   * @summary Update user
+   * {@link /user/:username}
+   */
+  async updateUser(
+    username: UpdateUserPathParams['username'],
+    data?: UpdateUserMutationRequest,
+    config: Partial<RequestConfig<UpdateUserMutationRequest>> & { client?: typeof fetch } = {},
+  ) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const requestData = data
+    const res = await request<UpdateUserMutationResponse, ResponseErrorConfig<Error>, UpdateUserMutationRequest>({
+      method: 'PUT',
+      url: `/user/${username}`,
+      data: requestData,
+      ...requestConfig,
+    })
+    return res.data
+  }
+
+  /**
+   * @description This can only be done by the logged in user.
+   * @summary Delete user
+   * {@link /user/:username}
+   */
+  async deleteUser(username: DeleteUserPathParams['username'], config: Partial<RequestConfig> & { client?: typeof fetch } = {}) {
+    const { client: request = this.#client, ...requestConfig } = config
+    const res = await request<DeleteUserMutationResponse, ResponseErrorConfig<DeleteUser400 | DeleteUser404>, unknown>({
+      method: 'DELETE',
+      url: `/user/${username}`,
+      ...requestConfig,
+    })
+    return res.data
+  }
+}