/* Generated by restful-react */

import React from 'react'
import { Get, GetProps, useGet, UseGetProps, Mutate, MutateProps, useMutate, UseMutateProps } from 'restful-react'

import { getConfig } from '../config'
export const SPEC_VERSION = '0.0.0'
export type EnumAccessGrant = number

export type EnumCheckPayloadKind = '' | 'markdown' | 'raw'

export type EnumCheckStatus = 'error' | 'failure' | 'pending' | 'running' | 'success'

export type EnumContentEncodingType = 'base64' | 'utf8'

export type EnumMembershipRole = 'contributor' | 'executor' | 'reader' | 'space_owner'

export type EnumMergeCheckStatus = string

export type EnumMergeMethod = 'merge' | 'squash' | 'rebase'

export type EnumParentResourceType = 'space' | 'repo'

export type EnumPathTargetType = string

export type EnumPrincipalType = 'service' | 'serviceaccount' | 'user'

export type EnumPullReqActivityKind = 'change-comment' | 'comment' | 'system'

export type EnumPullReqActivityType =
  | 'branch-delete'
  | 'branch-update'
  | 'code-comment'
  | 'comment'
  | 'merge'
  | 'review-submit'
  | 'state-change'
  | 'title-change'

export type EnumPullReqCommentStatus = 'active' | 'resolved'

export type EnumPullReqReviewDecision = 'approved' | 'changereq' | 'pending' | 'reviewed'

export type EnumPullReqReviewerType = 'assigned' | 'requested' | 'self_assigned'

export type EnumPullReqState = 'closed' | 'merged' | 'open'

export type EnumTokenType = string

export type EnumWebhookExecutionResult = 'fatal_error' | 'retriable_error' | 'success' | null

export type EnumWebhookParent = 'repo' | 'space'

export type EnumWebhookTrigger =
  | 'branch_created'
  | 'branch_deleted'
  | 'branch_updated'
  | 'pullreq_branch_updated'
  | 'pullreq_created'
  | 'pullreq_reopened'
  | 'tag_created'
  | 'tag_deleted'
  | 'tag_updated'

export interface GitrpcBlamePart {
  commit?: GitrpcCommit
  lines?: string[] | null
}

export interface GitrpcCommit {
  author?: GitrpcSignature
  committer?: GitrpcSignature
  message?: string
  sha?: string
  title?: string
}

export type GitrpcFileAction = 'CREATE' | 'UPDATE' | 'DELETE' | 'MOVE'

export interface GitrpcFileDiff {
  additions?: number
  changes?: number
  content_url?: string
  deletions?: number
  is_binary?: boolean
  is_submodule?: boolean
  old_path?: string
  old_sha?: string
  patch?: number[]
  path?: string
  sha?: string
  status?: string
}

export interface GitrpcIdentity {
  email?: string
  name?: string
}

export interface GitrpcPathDetails {
  last_commit?: GitrpcCommit
  path?: string
  size?: number
}

export interface GitrpcSignature {
  identity?: GitrpcIdentity
  when?: string
}

export interface OpenapiAdminUsersCreateRequest {
  display_name?: string
  email?: string
  password?: string
  uid?: string
}

export interface OpenapiAdminUsersUpdateRequest {
  display_name?: string | null
  email?: string | null
  password?: string | null
}

export interface OpenapiCalculateCommitDivergenceRequest {
  max_count?: number
  requests?: RepoCommitDivergenceRequest[] | null
}

export interface OpenapiCommentCreatePullReqRequest {
  line_end?: number
  line_end_new?: boolean
  line_start?: number
  line_start_new?: boolean
  parent_id?: number
  path?: string
  source_commit_sha?: string
  target_commit_sha?: string
  text?: string
}

export interface OpenapiCommentStatusPullReqRequest {
  status?: EnumPullReqCommentStatus
}

export interface OpenapiCommentUpdatePullReqRequest {
  text?: string
}

export interface OpenapiCommitFilesRequest {
  actions?: RepoCommitFileAction[] | null
  branch?: string
  message?: string
  new_branch?: string
  title?: string
}

export type OpenapiContent = RepoFileContent | OpenapiDirContent | RepoSymlinkContent | RepoSubmoduleContent

export interface OpenapiContentInfo {
  latest_commit?: TypesCommit
  name?: string
  path?: string
  sha?: string
  type?: OpenapiContentType
}

export type OpenapiContentType = 'file' | 'dir' | 'symlink' | 'submodule'

export interface OpenapiCreateBranchRequest {
  name?: string
  target?: string
}

export interface OpenapiCreateConnectorRequest {
  data?: string
  description?: string
  space_ref?: string
  type?: string
  uid?: string
}

export interface OpenapiCreateExecutionRequest {
  status?: string
}

export interface OpenapiCreatePathRequest {
  path?: string
}

export interface OpenapiCreatePipelineRequest {
  config_path?: string
  default_branch?: string
  description?: string
  uid?: string
}

export interface OpenapiCreatePullReqRequest {
  description?: string
  is_draft?: boolean
  source_branch?: string
  source_repo_ref?: string
  target_branch?: string
  title?: string
}

export interface OpenapiCreateRepoPathRequest {
  path?: string
}

export interface OpenapiCreateRepositoryRequest {
  default_branch?: string
  description?: string
  fork_id?: number
  git_ignore?: string
  is_public?: boolean
  license?: string
  parent_ref?: string
  readme?: boolean
  uid?: string
}

export interface OpenapiCreateSecretRequest {
  data?: string
  description?: string
  space_ref?: string
  uid?: string
}

export interface OpenapiCreateSpaceRequest {
  description?: string
  is_public?: boolean
  parent_ref?: string
  uid?: string
}

export interface OpenapiCreateTagRequest {
  message?: string
  name?: string
  target?: string
}

export interface OpenapiCreateTemplateRequest {
  data?: string
  description?: string
  space_ref?: string
  type?: string
  uid?: string
}

export interface OpenapiCreateTokenRequest {
  grants?: EnumAccessGrant
  lifetime?: TimeDuration
  uid?: string
}

export interface OpenapiCreateTriggerRequest {
  description?: string
  uid?: string
}

export interface OpenapiCreateWebhookRequest {
  description?: string
  display_name?: string
  enabled?: boolean
  insecure?: boolean
  secret?: string
  triggers?: EnumWebhookTrigger[] | null
  url?: string
}

export interface OpenapiDirContent {
  entries?: OpenapiContentInfo[] | null
}

export interface OpenapiGetContentOutput {
  content?: OpenapiContent
  latest_commit?: TypesCommit
  name?: string
  path?: string
  sha?: string
  type?: OpenapiContentType
}

export interface OpenapiLoginRequest {
  login_identifier?: string
  password?: string
}

export interface OpenapiMergePullReq {
  method?: EnumMergeMethod
  source_sha?: string
}

export interface OpenapiMoveRepoRequest {
  keep_as_alias?: boolean
  parent_ref?: string | null
  uid?: string | null
}

export interface OpenapiMoveSpaceRequest {
  keep_as_alias?: boolean
  parent_ref?: string | null
  uid?: string | null
}

export interface OpenapiPathsDetailsRequest {
  paths?: string[] | null
}

export interface OpenapiRegisterRequest {
  display_name?: string
  email?: string
  password?: string
  uid?: string
}

export interface OpenapiReviewSubmitPullReqRequest {
  commit_sha?: string
  decision?: EnumPullReqReviewDecision
  message?: string
}

export interface OpenapiReviewerAddPullReqRequest {
  reviewer_id?: number
}

export interface OpenapiStatePullReqRequest {
  is_draft?: boolean
  message?: string
  state?: EnumPullReqState
}

export interface OpenapiUpdateAdminRequest {
  admin?: boolean
}

export interface OpenapiUpdateConnectorRequest {
  data?: string
  description?: string
  uid?: string
}

export interface OpenapiUpdateExecutionRequest {
  status?: string
}

export interface OpenapiUpdatePipelineRequest {
  config_path?: string
  description?: string
  uid?: string
}

export interface OpenapiUpdatePullReqRequest {
  description?: string
  title?: string
}

export interface OpenapiUpdateRepoRequest {
  description?: string | null
  is_public?: boolean | null
}

export interface OpenapiUpdateSecretRequest {
  data?: string
  description?: string
  uid?: string
}

export interface OpenapiUpdateSpaceRequest {
  description?: string | null
  is_public?: boolean | null
}

export interface OpenapiUpdateTemplateRequest {
  data?: string
  description?: string
  uid?: string
}

export interface OpenapiUpdateTriggerRequest {
  description?: string
  uid?: string
}

export interface OpenapiUpdateWebhookRequest {
  description?: string | null
  display_name?: string | null
  enabled?: boolean | null
  insecure?: boolean | null
  secret?: string | null
  triggers?: EnumWebhookTrigger[] | null
  url?: string | null
}

export interface OpenapiWebhookType {
  created?: number
  created_by?: number
  description?: string
  display_name?: string
  enabled?: boolean
  has_secret?: boolean
  id?: number
  insecure?: boolean
  latest_execution_result?: EnumWebhookExecutionResult
  parent_id?: number
  parent_type?: EnumWebhookParent
  triggers?: EnumWebhookTrigger[] | null
  updated?: number
  url?: string
  version?: number
}

export interface RepoBranch {
  commit?: TypesCommit
  name?: string
  sha?: string
}

export interface RepoCommitDivergence {
  ahead?: number
  behind?: number
}

export interface RepoCommitDivergenceRequest {
  from?: string
  to?: string
}

export interface RepoCommitFileAction {
  action?: GitrpcFileAction
  encoding?: EnumContentEncodingType
  path?: string
  payload?: string
  sha?: string
}

export interface RepoCommitFilesResponse {
  commit_id?: string
}

export interface RepoCommitTag {
  commit?: TypesCommit
  is_annotated?: boolean
  message?: string
  name?: string
  sha?: string
  tagger?: TypesSignature
  title?: string
}

// tslint:disable-next-line:no-empty-interface
export interface RepoContent {}

export interface RepoContentInfo {
  latest_commit?: TypesCommit
  name?: string
  path?: string
  sha?: string
  type?: RepoContentType
}

export type RepoContentType = string

export interface RepoFileContent {
  data?: string
  data_size?: number
  encoding?: EnumContentEncodingType
  size?: number
}

export interface RepoMergeCheck {
  conflict_files?: string[]
  mergeable?: boolean
}

export interface RepoPathsDetailsOutput {
  details?: GitrpcPathDetails[] | null
}

export interface RepoSubmoduleContent {
  commit_sha?: string
  url?: string
}

export interface RepoSymlinkContent {
  size?: number
  target?: string
}

export interface SystemConfigOutput {
  sign_up_allowed?: boolean
}

export type TimeDuration = number | null

export interface TypesCheck {
  created?: number
  id?: number
  link?: string
  metadata?: {}
  payload?: TypesCheckPayload
  reported_by?: TypesPrincipalInfo
  status?: EnumCheckStatus
  summary?: string
  uid?: string
  updated?: number
}

export interface TypesCheckPayload {
  data?: {}
  kind?: EnumCheckPayloadKind
  version?: string
}

export interface TypesCodeCommentFields {
  line_new?: number
  line_old?: number
  merge_base_sha?: string
  outdated?: boolean
  path?: string
  source_sha?: string
  span_new?: number
  span_old?: number
}

export interface TypesCommit {
  author?: TypesSignature
  committer?: TypesSignature
  message?: string
  sha?: string
  title?: string
}

export interface TypesConnector {
  created?: number
  data?: string
  description?: string
  id?: number
  space_id?: number
  type?: string
  uid?: string
  updated?: number
}

export interface TypesDiffStats {
  commits?: number
  files_changed?: number
}

export interface TypesExecution {
  action?: string
  after?: string
  author_avatar?: string
  author_email?: string
  author_login?: string
  author_name?: string
  before?: string
  created?: number
  cron?: string
  debug?: boolean
  deploy_id?: number
  deploy_to?: string
  error?: string
  event?: string
  finished?: number
  link?: string
  message?: string
  number?: number
  params?: {
    [key: string]: string
  }
  parent?: number
  pipeline_id?: number
  ref?: string
  repo_id?: number
  sender?: string
  source?: string
  source_repo?: string
  stages?: TypesStage[]
  started?: number
  status?: string
  target?: string
  timestamp?: number
  title?: string
  trigger?: string
  updated?: number
}

export interface TypesIdentity {
  email?: string
  name?: string
}

export interface TypesListCommitResponse {
  commits?: TypesCommit[] | null
  rename_details?: TypesRenameDetails[] | null
  total_commits?: number
}

export interface TypesMembershipSpace {
  added_by?: TypesPrincipalInfo
  created?: number
  role?: EnumMembershipRole
  space?: TypesSpace
  updated?: number
}

export interface TypesMembershipUser {
  added_by?: TypesPrincipalInfo
  created?: number
  principal?: TypesPrincipalInfo
  role?: EnumMembershipRole
  updated?: number
}

export interface TypesMergeResponse {
  conflict_files?: string[]
  sha?: string
}

export interface TypesPath {
  created?: number
  created_by?: number
  id?: number
  is_primary?: boolean
  target_id?: number
  target_type?: EnumPathTargetType
  updated?: number
  value?: string
}

export interface TypesPipeline {
  config_path?: string
  created?: number
  default_branch?: string
  description?: string
  execution?: TypesExecution
  id?: number
  repo_id?: number
  seq?: number
  uid?: string
  updated?: number
}

export interface TypesPlugin {
  description?: string
  logo?: string
  spec?: string
  uid?: string
}

export interface TypesPrincipalInfo {
  created?: number
  display_name?: string
  email?: string
  id?: number
  type?: EnumPrincipalType
  uid?: string
  updated?: number
}

export interface TypesPullReq {
  author?: TypesPrincipalInfo
  created?: number
  description?: string
  edited?: number
  is_draft?: boolean
  merge_base_sha?: string
  merge_check_status?: EnumMergeCheckStatus
  merge_conflicts?: string | null
  merge_method?: EnumMergeMethod
  merge_sha?: string | null
  merge_target_sha?: string | null
  merged?: number | null
  merger?: TypesPrincipalInfo
  number?: number
  source_branch?: string
  source_repo_id?: number
  source_sha?: string
  state?: EnumPullReqState
  stats?: TypesPullReqStats
  target_branch?: string
  target_repo_id?: number
  title?: string
}

export interface TypesPullReqActivity {
  author?: TypesPrincipalInfo
  code_comment?: TypesCodeCommentFields
  created?: number
  deleted?: number | null
  edited?: number
  id?: number
  kind?: EnumPullReqActivityKind
  metadata?: { [key: string]: any } | null
  order?: number
  parent_id?: number | null
  payload?: {}
  pullreq_id?: number
  repo_id?: number
  resolved?: number | null
  resolver?: TypesPrincipalInfo
  sub_order?: number
  text?: string
  type?: EnumPullReqActivityType
}

export interface TypesPullReqReviewer {
  added_by?: TypesPrincipalInfo
  created?: number
  latest_review_id?: number | null
  review_decision?: EnumPullReqReviewDecision
  reviewer?: TypesPrincipalInfo
  sha?: string
  type?: EnumPullReqReviewerType
  updated?: number
}

export interface TypesPullReqStats {
  commits?: number
  conversations?: number
  files_changed?: number
  unresolved_count?: number
}

export interface TypesRenameDetails {
  commit_sha_after?: string
  commit_sha_before?: string
  new_path?: string
  old_path?: string
}

export interface TypesRepository {
  created?: number
  created_by?: number
  default_branch?: string
  description?: string
  fork_id?: number
  git_url?: string
  id?: number
  is_public?: boolean
  num_closed_pulls?: number
  num_forks?: number
  num_merged_pulls?: number
  num_open_pulls?: number
  num_pulls?: number
  parent_id?: number
  path?: string
  uid?: string
  updated?: number
}

export interface TypesSecret {
  created?: number
  description?: string
  id?: number
  space_id?: number
  uid?: string
  updated?: number
}

export interface TypesServiceAccount {
  admin?: boolean
  blocked?: boolean
  created?: number
  display_name?: string
  email?: string
  parent_id?: number
  parent_type?: EnumParentResourceType
  uid?: string
  updated?: number
}

export interface TypesSignature {
  identity?: TypesIdentity
  when?: string
}

export interface TypesSpace {
  created?: number
  created_by?: number
  description?: string
  id?: number
  is_public?: boolean
  parent_id?: number
  path?: string
  uid?: string
  updated?: number
}

export interface TypesStage {
  arch?: string
  depends_on?: string[] | null
  errignore?: boolean
  error?: string
  execution_id?: number
  exit_code?: number
  kernel?: string
  kind?: string
  labels?: {
    [key: string]: string
  }
  limit?: number
  machine?: string
  name?: string
  number?: number
  on_failure?: boolean
  on_success?: boolean
  os?: string
  started?: number
  status?: string
  steps?: TypesStep[]
  stopped?: number
  throttle?: number
  type?: string
  variant?: string
}

export interface TypesStep {
  depends_on?: string[] | null
  detached?: boolean
  errignore?: boolean
  error?: string
  exit_code?: number
  image?: string
  name?: string
  number?: number
  schema?: string
  started?: number
  status?: string
  stopped?: number
}

export interface TypesTemplate {
  created?: number
  data?: string
  description?: string
  id?: number
  space_id?: number
  uid?: string
  updated?: number
}

export interface TypesToken {
  created_by?: number
  expires_at?: number | null
  grants?: EnumAccessGrant
  issued_at?: number
  principal_id?: number
  type?: EnumTokenType
  uid?: string
}

export interface TypesTokenResponse {
  access_token?: string
  token?: TypesToken
}

export interface TypesTrigger {
  created?: number
  description?: string
  id?: number
  pipeline_id?: number
  uid?: string
  updated?: number
}

export interface TypesUser {
  admin?: boolean
  blocked?: boolean
  created?: number
  display_name?: string
  email?: string
  uid?: string
  updated?: number
}

export interface TypesWebhookExecution {
  created?: number
  duration?: number
  error?: string
  id?: number
  request?: TypesWebhookExecutionRequest
  response?: TypesWebhookExecutionResponse
  result?: EnumWebhookExecutionResult
  retrigger_of?: number | null
  retriggerable?: boolean
  trigger_type?: EnumWebhookTrigger
  webhook_id?: number
}

export interface TypesWebhookExecutionRequest {
  body?: string
  headers?: string
  url?: string
}

export interface TypesWebhookExecutionResponse {
  body?: string
  headers?: string
  status?: string
  status_code?: number
}

export interface UserUpdateInput {
  display_name?: string | null
  email?: string | null
  password?: string | null
}

export interface UsererrorError {
  message?: string
  values?: { [key: string]: any }
}

export interface AdminListUsersQueryParams {
  sort?: 'id' | 'email' | 'created' | 'updated'
  order?: 'asc' | 'desc'
  page?: number
  limit?: number
}

export type AdminListUsersProps = Omit<GetProps<TypesUser[], UsererrorError, AdminListUsersQueryParams, void>, 'path'>

export const AdminListUsers = (props: AdminListUsersProps) => (
  <Get<TypesUser[], UsererrorError, AdminListUsersQueryParams, void>
    path={`/admin/users`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseAdminListUsersProps = Omit<
  UseGetProps<TypesUser[], UsererrorError, AdminListUsersQueryParams, void>,
  'path'
>

export const useAdminListUsers = (props: UseAdminListUsersProps) =>
  useGet<TypesUser[], UsererrorError, AdminListUsersQueryParams, void>(`/admin/users`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type AdminCreateUserProps = Omit<
  MutateProps<TypesUser, UsererrorError, void, OpenapiAdminUsersCreateRequest, void>,
  'path' | 'verb'
>

export const AdminCreateUser = (props: AdminCreateUserProps) => (
  <Mutate<TypesUser, UsererrorError, void, OpenapiAdminUsersCreateRequest, void>
    verb="POST"
    path={`/admin/users`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseAdminCreateUserProps = Omit<
  UseMutateProps<TypesUser, UsererrorError, void, OpenapiAdminUsersCreateRequest, void>,
  'path' | 'verb'
>

export const useAdminCreateUser = (props: UseAdminCreateUserProps) =>
  useMutate<TypesUser, UsererrorError, void, OpenapiAdminUsersCreateRequest, void>('POST', `/admin/users`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type AdminDeleteUserProps = Omit<MutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const AdminDeleteUser = (props: AdminDeleteUserProps) => (
  <Mutate<void, UsererrorError, void, string, void>
    verb="DELETE"
    path={`/admin/users`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseAdminDeleteUserProps = Omit<UseMutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const useAdminDeleteUser = (props: UseAdminDeleteUserProps) =>
  useMutate<void, UsererrorError, void, string, void>('DELETE', `/admin/users`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export interface AdminGetUserPathParams {
  user_uid: string
}

export type AdminGetUserProps = Omit<GetProps<TypesUser, UsererrorError, void, AdminGetUserPathParams>, 'path'> &
  AdminGetUserPathParams

export const AdminGetUser = ({ user_uid, ...props }: AdminGetUserProps) => (
  <Get<TypesUser, UsererrorError, void, AdminGetUserPathParams>
    path={`/admin/users/${user_uid}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseAdminGetUserProps = Omit<UseGetProps<TypesUser, UsererrorError, void, AdminGetUserPathParams>, 'path'> &
  AdminGetUserPathParams

export const useAdminGetUser = ({ user_uid, ...props }: UseAdminGetUserProps) =>
  useGet<TypesUser, UsererrorError, void, AdminGetUserPathParams>(
    (paramsInPath: AdminGetUserPathParams) => `/admin/users/${paramsInPath.user_uid}`,
    { base: getConfig('code/api/v1'), pathParams: { user_uid }, ...props }
  )

export interface AdminUpdateUserPathParams {
  user_uid: string
}

export type AdminUpdateUserProps = Omit<
  MutateProps<TypesUser, UsererrorError, void, OpenapiAdminUsersUpdateRequest, AdminUpdateUserPathParams>,
  'path' | 'verb'
> &
  AdminUpdateUserPathParams

export const AdminUpdateUser = ({ user_uid, ...props }: AdminUpdateUserProps) => (
  <Mutate<TypesUser, UsererrorError, void, OpenapiAdminUsersUpdateRequest, AdminUpdateUserPathParams>
    verb="PATCH"
    path={`/admin/users/${user_uid}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseAdminUpdateUserProps = Omit<
  UseMutateProps<TypesUser, UsererrorError, void, OpenapiAdminUsersUpdateRequest, AdminUpdateUserPathParams>,
  'path' | 'verb'
> &
  AdminUpdateUserPathParams

export const useAdminUpdateUser = ({ user_uid, ...props }: UseAdminUpdateUserProps) =>
  useMutate<TypesUser, UsererrorError, void, OpenapiAdminUsersUpdateRequest, AdminUpdateUserPathParams>(
    'PATCH',
    (paramsInPath: AdminUpdateUserPathParams) => `/admin/users/${paramsInPath.user_uid}`,
    { base: getConfig('code/api/v1'), pathParams: { user_uid }, ...props }
  )

export interface UpdateUserAdminPathParams {
  user_uid: string
}

export type UpdateUserAdminProps = Omit<
  MutateProps<TypesUser, UsererrorError, void, OpenapiUpdateAdminRequest, UpdateUserAdminPathParams>,
  'path' | 'verb'
> &
  UpdateUserAdminPathParams

export const UpdateUserAdmin = ({ user_uid, ...props }: UpdateUserAdminProps) => (
  <Mutate<TypesUser, UsererrorError, void, OpenapiUpdateAdminRequest, UpdateUserAdminPathParams>
    verb="PATCH"
    path={`/admin/users/${user_uid}/admin`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateUserAdminProps = Omit<
  UseMutateProps<TypesUser, UsererrorError, void, OpenapiUpdateAdminRequest, UpdateUserAdminPathParams>,
  'path' | 'verb'
> &
  UpdateUserAdminPathParams

export const useUpdateUserAdmin = ({ user_uid, ...props }: UseUpdateUserAdminProps) =>
  useMutate<TypesUser, UsererrorError, void, OpenapiUpdateAdminRequest, UpdateUserAdminPathParams>(
    'PATCH',
    (paramsInPath: UpdateUserAdminPathParams) => `/admin/users/${paramsInPath.user_uid}/admin`,
    { base: getConfig('code/api/v1'), pathParams: { user_uid }, ...props }
  )

export type CreateConnectorProps = Omit<
  MutateProps<TypesConnector, UsererrorError, void, OpenapiCreateConnectorRequest, void>,
  'path' | 'verb'
>

export const CreateConnector = (props: CreateConnectorProps) => (
  <Mutate<TypesConnector, UsererrorError, void, OpenapiCreateConnectorRequest, void>
    verb="POST"
    path={`/connectors`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateConnectorProps = Omit<
  UseMutateProps<TypesConnector, UsererrorError, void, OpenapiCreateConnectorRequest, void>,
  'path' | 'verb'
>

export const useCreateConnector = (props: UseCreateConnectorProps) =>
  useMutate<TypesConnector, UsererrorError, void, OpenapiCreateConnectorRequest, void>('POST', `/connectors`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type DeleteConnectorProps = Omit<MutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const DeleteConnector = (props: DeleteConnectorProps) => (
  <Mutate<void, UsererrorError, void, string, void>
    verb="DELETE"
    path={`/connectors`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteConnectorProps = Omit<UseMutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const useDeleteConnector = (props: UseDeleteConnectorProps) =>
  useMutate<void, UsererrorError, void, string, void>('DELETE', `/connectors`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export interface FindConnectorPathParams {
  connector_ref: string
}

export type FindConnectorProps = Omit<GetProps<TypesConnector, UsererrorError, void, FindConnectorPathParams>, 'path'> &
  FindConnectorPathParams

export const FindConnector = ({ connector_ref, ...props }: FindConnectorProps) => (
  <Get<TypesConnector, UsererrorError, void, FindConnectorPathParams>
    path={`/connectors/${connector_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseFindConnectorProps = Omit<
  UseGetProps<TypesConnector, UsererrorError, void, FindConnectorPathParams>,
  'path'
> &
  FindConnectorPathParams

export const useFindConnector = ({ connector_ref, ...props }: UseFindConnectorProps) =>
  useGet<TypesConnector, UsererrorError, void, FindConnectorPathParams>(
    (paramsInPath: FindConnectorPathParams) => `/connectors/${paramsInPath.connector_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { connector_ref }, ...props }
  )

export interface UpdateConnectorPathParams {
  connector_ref: string
}

export type UpdateConnectorProps = Omit<
  MutateProps<TypesConnector, UsererrorError, void, OpenapiUpdateConnectorRequest, UpdateConnectorPathParams>,
  'path' | 'verb'
> &
  UpdateConnectorPathParams

export const UpdateConnector = ({ connector_ref, ...props }: UpdateConnectorProps) => (
  <Mutate<TypesConnector, UsererrorError, void, OpenapiUpdateConnectorRequest, UpdateConnectorPathParams>
    verb="PATCH"
    path={`/connectors/${connector_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateConnectorProps = Omit<
  UseMutateProps<TypesConnector, UsererrorError, void, OpenapiUpdateConnectorRequest, UpdateConnectorPathParams>,
  'path' | 'verb'
> &
  UpdateConnectorPathParams

export const useUpdateConnector = ({ connector_ref, ...props }: UseUpdateConnectorProps) =>
  useMutate<TypesConnector, UsererrorError, void, OpenapiUpdateConnectorRequest, UpdateConnectorPathParams>(
    'PATCH',
    (paramsInPath: UpdateConnectorPathParams) => `/connectors/${paramsInPath.connector_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { connector_ref }, ...props }
  )

export type OnLoginProps = Omit<
  MutateProps<TypesTokenResponse, UsererrorError, void, OpenapiLoginRequest, void>,
  'path' | 'verb'
>

export const OnLogin = (props: OnLoginProps) => (
  <Mutate<TypesTokenResponse, UsererrorError, void, OpenapiLoginRequest, void>
    verb="POST"
    path={`/login`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseOnLoginProps = Omit<
  UseMutateProps<TypesTokenResponse, UsererrorError, void, OpenapiLoginRequest, void>,
  'path' | 'verb'
>

export const useOnLogin = (props: UseOnLoginProps) =>
  useMutate<TypesTokenResponse, UsererrorError, void, OpenapiLoginRequest, void>('POST', `/login`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type OpLogoutProps = Omit<MutateProps<void, UsererrorError, void, void, void>, 'path' | 'verb'>

export const OpLogout = (props: OpLogoutProps) => (
  <Mutate<void, UsererrorError, void, void, void>
    verb="POST"
    path={`/logout`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseOpLogoutProps = Omit<UseMutateProps<void, UsererrorError, void, void, void>, 'path' | 'verb'>

export const useOpLogout = (props: UseOpLogoutProps) =>
  useMutate<void, UsererrorError, void, void, void>('POST', `/logout`, { base: getConfig('code/api/v1'), ...props })

export interface ListPluginsQueryParams {
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
  /**
   * The substring which is used to filter the plugins by their name.
   */
  query?: string
}

export type ListPluginsProps = Omit<GetProps<TypesPlugin[], UsererrorError, ListPluginsQueryParams, void>, 'path'>

export const ListPlugins = (props: ListPluginsProps) => (
  <Get<TypesPlugin[], UsererrorError, ListPluginsQueryParams, void>
    path={`/plugins`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListPluginsProps = Omit<UseGetProps<TypesPlugin[], UsererrorError, ListPluginsQueryParams, void>, 'path'>

export const useListPlugins = (props: UseListPluginsProps) =>
  useGet<TypesPlugin[], UsererrorError, ListPluginsQueryParams, void>(`/plugins`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export interface ListPrincipalsQueryParams {
  /**
   * The substring by which the principals are filtered.
   */
  query?: string
  /**
   * The account ID the principals are retrieved for (Not required in standalone).
   */
  accountIdentifier?: string
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
  /**
   * The types of principals to include.
   */
  type?: ('service' | 'serviceaccount' | 'user')[]
}

export type ListPrincipalsProps = Omit<
  GetProps<TypesPrincipalInfo[], UsererrorError, ListPrincipalsQueryParams, void>,
  'path'
>

export const ListPrincipals = (props: ListPrincipalsProps) => (
  <Get<TypesPrincipalInfo[], UsererrorError, ListPrincipalsQueryParams, void>
    path={`/principals`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListPrincipalsProps = Omit<
  UseGetProps<TypesPrincipalInfo[], UsererrorError, ListPrincipalsQueryParams, void>,
  'path'
>

export const useListPrincipals = (props: UseListPrincipalsProps) =>
  useGet<TypesPrincipalInfo[], UsererrorError, ListPrincipalsQueryParams, void>(`/principals`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type OnRegisterProps = Omit<
  MutateProps<TypesTokenResponse, UsererrorError, void, OpenapiRegisterRequest, void>,
  'path' | 'verb'
>

export const OnRegister = (props: OnRegisterProps) => (
  <Mutate<TypesTokenResponse, UsererrorError, void, OpenapiRegisterRequest, void>
    verb="POST"
    path={`/register`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseOnRegisterProps = Omit<
  UseMutateProps<TypesTokenResponse, UsererrorError, void, OpenapiRegisterRequest, void>,
  'path' | 'verb'
>

export const useOnRegister = (props: UseOnRegisterProps) =>
  useMutate<TypesTokenResponse, UsererrorError, void, OpenapiRegisterRequest, void>('POST', `/register`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export interface CreateRepositoryQueryParams {
  /**
   * path of parent space (Not needed in standalone).
   */
  space_path?: string
}

export type CreateRepositoryProps = Omit<
  MutateProps<TypesRepository, UsererrorError, CreateRepositoryQueryParams, OpenapiCreateRepositoryRequest, void>,
  'path' | 'verb'
>

export const CreateRepository = (props: CreateRepositoryProps) => (
  <Mutate<TypesRepository, UsererrorError, CreateRepositoryQueryParams, OpenapiCreateRepositoryRequest, void>
    verb="POST"
    path={`/repos`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateRepositoryProps = Omit<
  UseMutateProps<TypesRepository, UsererrorError, CreateRepositoryQueryParams, OpenapiCreateRepositoryRequest, void>,
  'path' | 'verb'
>

export const useCreateRepository = (props: UseCreateRepositoryProps) =>
  useMutate<TypesRepository, UsererrorError, CreateRepositoryQueryParams, OpenapiCreateRepositoryRequest, void>(
    'POST',
    `/repos`,
    { base: getConfig('code/api/v1'), ...props }
  )

export type DeleteRepositoryProps = Omit<MutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const DeleteRepository = (props: DeleteRepositoryProps) => (
  <Mutate<void, UsererrorError, void, string, void>
    verb="DELETE"
    path={`/repos`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteRepositoryProps = Omit<UseMutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const useDeleteRepository = (props: UseDeleteRepositoryProps) =>
  useMutate<void, UsererrorError, void, string, void>('DELETE', `/repos`, { base: getConfig('code/api/v1'), ...props })

export interface FindRepositoryPathParams {
  repo_ref: string
}

export type FindRepositoryProps = Omit<
  GetProps<TypesRepository, UsererrorError, void, FindRepositoryPathParams>,
  'path'
> &
  FindRepositoryPathParams

export const FindRepository = ({ repo_ref, ...props }: FindRepositoryProps) => (
  <Get<TypesRepository, UsererrorError, void, FindRepositoryPathParams>
    path={`/repos/${repo_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseFindRepositoryProps = Omit<
  UseGetProps<TypesRepository, UsererrorError, void, FindRepositoryPathParams>,
  'path'
> &
  FindRepositoryPathParams

export const useFindRepository = ({ repo_ref, ...props }: UseFindRepositoryProps) =>
  useGet<TypesRepository, UsererrorError, void, FindRepositoryPathParams>(
    (paramsInPath: FindRepositoryPathParams) => `/repos/${paramsInPath.repo_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface UpdateRepositoryPathParams {
  repo_ref: string
}

export type UpdateRepositoryProps = Omit<
  MutateProps<TypesRepository, UsererrorError, void, OpenapiUpdateRepoRequest, UpdateRepositoryPathParams>,
  'path' | 'verb'
> &
  UpdateRepositoryPathParams

export const UpdateRepository = ({ repo_ref, ...props }: UpdateRepositoryProps) => (
  <Mutate<TypesRepository, UsererrorError, void, OpenapiUpdateRepoRequest, UpdateRepositoryPathParams>
    verb="PATCH"
    path={`/repos/${repo_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateRepositoryProps = Omit<
  UseMutateProps<TypesRepository, UsererrorError, void, OpenapiUpdateRepoRequest, UpdateRepositoryPathParams>,
  'path' | 'verb'
> &
  UpdateRepositoryPathParams

export const useUpdateRepository = ({ repo_ref, ...props }: UseUpdateRepositoryProps) =>
  useMutate<TypesRepository, UsererrorError, void, OpenapiUpdateRepoRequest, UpdateRepositoryPathParams>(
    'PATCH',
    (paramsInPath: UpdateRepositoryPathParams) => `/repos/${paramsInPath.repo_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface GetBlameQueryParams {
  /**
   * The git reference (branch / tag / commitID) that will be used to retrieve the data. If no value is provided the default branch of the repository is used.
   */
  git_ref?: string
  /**
   * Line number from which the file data is considered
   */
  line_from?: number
  /**
   * Line number to which the file data is considered
   */
  line_to?: number
}

export interface GetBlamePathParams {
  repo_ref: string
  path: string
}

export type GetBlameProps = Omit<
  GetProps<GitrpcBlamePart[], UsererrorError, GetBlameQueryParams, GetBlamePathParams>,
  'path'
> &
  GetBlamePathParams

export const GetBlame = ({ repo_ref, path, ...props }: GetBlameProps) => (
  <Get<GitrpcBlamePart[], UsererrorError, GetBlameQueryParams, GetBlamePathParams>
    path={`/repos/${repo_ref}/blame/${path}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetBlameProps = Omit<
  UseGetProps<GitrpcBlamePart[], UsererrorError, GetBlameQueryParams, GetBlamePathParams>,
  'path'
> &
  GetBlamePathParams

export const useGetBlame = ({ repo_ref, path, ...props }: UseGetBlameProps) =>
  useGet<GitrpcBlamePart[], UsererrorError, GetBlameQueryParams, GetBlamePathParams>(
    (paramsInPath: GetBlamePathParams) => `/repos/${paramsInPath.repo_ref}/blame/${paramsInPath.path}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, path }, ...props }
  )

export interface ListBranchesQueryParams {
  /**
   * Indicates whether optional commit information should be included in the response.
   */
  include_commit?: boolean
  /**
   * The substring by which the branches are filtered.
   */
  query?: string
  /**
   * The order of the output.
   */
  order?: 'asc' | 'desc'
  /**
   * The data by which the branches are sorted.
   */
  sort?: 'name' | 'date'
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListBranchesPathParams {
  repo_ref: string
}

export type ListBranchesProps = Omit<
  GetProps<RepoBranch[], UsererrorError, ListBranchesQueryParams, ListBranchesPathParams>,
  'path'
> &
  ListBranchesPathParams

export const ListBranches = ({ repo_ref, ...props }: ListBranchesProps) => (
  <Get<RepoBranch[], UsererrorError, ListBranchesQueryParams, ListBranchesPathParams>
    path={`/repos/${repo_ref}/branches`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListBranchesProps = Omit<
  UseGetProps<RepoBranch[], UsererrorError, ListBranchesQueryParams, ListBranchesPathParams>,
  'path'
> &
  ListBranchesPathParams

export const useListBranches = ({ repo_ref, ...props }: UseListBranchesProps) =>
  useGet<RepoBranch[], UsererrorError, ListBranchesQueryParams, ListBranchesPathParams>(
    (paramsInPath: ListBranchesPathParams) => `/repos/${paramsInPath.repo_ref}/branches`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface CreateBranchPathParams {
  repo_ref: string
}

export type CreateBranchProps = Omit<
  MutateProps<RepoBranch, UsererrorError, void, OpenapiCreateBranchRequest, CreateBranchPathParams>,
  'path' | 'verb'
> &
  CreateBranchPathParams

export const CreateBranch = ({ repo_ref, ...props }: CreateBranchProps) => (
  <Mutate<RepoBranch, UsererrorError, void, OpenapiCreateBranchRequest, CreateBranchPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/branches`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateBranchProps = Omit<
  UseMutateProps<RepoBranch, UsererrorError, void, OpenapiCreateBranchRequest, CreateBranchPathParams>,
  'path' | 'verb'
> &
  CreateBranchPathParams

export const useCreateBranch = ({ repo_ref, ...props }: UseCreateBranchProps) =>
  useMutate<RepoBranch, UsererrorError, void, OpenapiCreateBranchRequest, CreateBranchPathParams>(
    'POST',
    (paramsInPath: CreateBranchPathParams) => `/repos/${paramsInPath.repo_ref}/branches`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface DeleteBranchPathParams {
  repo_ref: string
}

export type DeleteBranchProps = Omit<
  MutateProps<void, UsererrorError, void, string, DeleteBranchPathParams>,
  'path' | 'verb'
> &
  DeleteBranchPathParams

export const DeleteBranch = ({ repo_ref, ...props }: DeleteBranchProps) => (
  <Mutate<void, UsererrorError, void, string, DeleteBranchPathParams>
    verb="DELETE"
    path={`/repos/${repo_ref}/branches`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteBranchProps = Omit<
  UseMutateProps<void, UsererrorError, void, string, DeleteBranchPathParams>,
  'path' | 'verb'
> &
  DeleteBranchPathParams

export const useDeleteBranch = ({ repo_ref, ...props }: UseDeleteBranchProps) =>
  useMutate<void, UsererrorError, void, string, DeleteBranchPathParams>(
    'DELETE',
    (paramsInPath: DeleteBranchPathParams) => `/repos/${paramsInPath.repo_ref}/branches`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface GetBranchPathParams {
  repo_ref: string
  branch_name: string
}

export type GetBranchProps = Omit<GetProps<RepoBranch, UsererrorError, void, GetBranchPathParams>, 'path'> &
  GetBranchPathParams

export const GetBranch = ({ repo_ref, branch_name, ...props }: GetBranchProps) => (
  <Get<RepoBranch, UsererrorError, void, GetBranchPathParams>
    path={`/repos/${repo_ref}/branches/${branch_name}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetBranchProps = Omit<UseGetProps<RepoBranch, UsererrorError, void, GetBranchPathParams>, 'path'> &
  GetBranchPathParams

export const useGetBranch = ({ repo_ref, branch_name, ...props }: UseGetBranchProps) =>
  useGet<RepoBranch, UsererrorError, void, GetBranchPathParams>(
    (paramsInPath: GetBranchPathParams) => `/repos/${paramsInPath.repo_ref}/branches/${paramsInPath.branch_name}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, branch_name }, ...props }
  )

export interface ListStatusCheckResultsQueryParams {
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListStatusCheckResultsPathParams {
  repo_ref: string
  commit_sha: string
}

export type ListStatusCheckResultsProps = Omit<
  GetProps<TypesCheck[], UsererrorError, ListStatusCheckResultsQueryParams, ListStatusCheckResultsPathParams>,
  'path'
> &
  ListStatusCheckResultsPathParams

export const ListStatusCheckResults = ({ repo_ref, commit_sha, ...props }: ListStatusCheckResultsProps) => (
  <Get<TypesCheck[], UsererrorError, ListStatusCheckResultsQueryParams, ListStatusCheckResultsPathParams>
    path={`/repos/${repo_ref}/checks/commits/${commit_sha}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListStatusCheckResultsProps = Omit<
  UseGetProps<TypesCheck[], UsererrorError, ListStatusCheckResultsQueryParams, ListStatusCheckResultsPathParams>,
  'path'
> &
  ListStatusCheckResultsPathParams

export const useListStatusCheckResults = ({ repo_ref, commit_sha, ...props }: UseListStatusCheckResultsProps) =>
  useGet<TypesCheck[], UsererrorError, ListStatusCheckResultsQueryParams, ListStatusCheckResultsPathParams>(
    (paramsInPath: ListStatusCheckResultsPathParams) =>
      `/repos/${paramsInPath.repo_ref}/checks/commits/${paramsInPath.commit_sha}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, commit_sha }, ...props }
  )

export interface ReportStatusCheckResultsPathParams {
  repo_ref: string
  commit_sha: string
}

export interface ReportStatusCheckResultsRequestBody {
  check_uid?: string
  link?: string
  payload?: TypesCheckPayload
  status?: EnumCheckStatus
  summary?: string
}

export type ReportStatusCheckResultsProps = Omit<
  MutateProps<
    TypesCheck,
    UsererrorError,
    void,
    ReportStatusCheckResultsRequestBody,
    ReportStatusCheckResultsPathParams
  >,
  'path' | 'verb'
> &
  ReportStatusCheckResultsPathParams

export const ReportStatusCheckResults = ({ repo_ref, commit_sha, ...props }: ReportStatusCheckResultsProps) => (
  <Mutate<TypesCheck, UsererrorError, void, ReportStatusCheckResultsRequestBody, ReportStatusCheckResultsPathParams>
    verb="PUT"
    path={`/repos/${repo_ref}/checks/commits/${commit_sha}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseReportStatusCheckResultsProps = Omit<
  UseMutateProps<
    TypesCheck,
    UsererrorError,
    void,
    ReportStatusCheckResultsRequestBody,
    ReportStatusCheckResultsPathParams
  >,
  'path' | 'verb'
> &
  ReportStatusCheckResultsPathParams

export const useReportStatusCheckResults = ({ repo_ref, commit_sha, ...props }: UseReportStatusCheckResultsProps) =>
  useMutate<TypesCheck, UsererrorError, void, ReportStatusCheckResultsRequestBody, ReportStatusCheckResultsPathParams>(
    'PUT',
    (paramsInPath: ReportStatusCheckResultsPathParams) =>
      `/repos/${paramsInPath.repo_ref}/checks/commits/${paramsInPath.commit_sha}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, commit_sha }, ...props }
  )

export interface ListCommitsQueryParams {
  /**
   * The git reference (branch / tag / commitID) that will be used to retrieve the data. If no value is provided the default branch of the repository is used.
   */
  git_ref?: string
  /**
   * The result should only contain commits that occurred after the provided reference.
   */
  after?: string
  /**
   * Path for which commit information should be retrieved
   */
  path?: string
  /**
   * Epoch since when commit information should be retrieved.
   */
  since?: number
  /**
   * Epoch until when commit information should be retrieved.
   */
  until?: number
  /**
   * Committer pattern for which commit information should be retrieved.
   */
  committer?: string
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListCommitsPathParams {
  repo_ref: string
}

export type ListCommitsProps = Omit<
  GetProps<TypesListCommitResponse[], UsererrorError, ListCommitsQueryParams, ListCommitsPathParams>,
  'path'
> &
  ListCommitsPathParams

export const ListCommits = ({ repo_ref, ...props }: ListCommitsProps) => (
  <Get<TypesListCommitResponse[], UsererrorError, ListCommitsQueryParams, ListCommitsPathParams>
    path={`/repos/${repo_ref}/commits`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListCommitsProps = Omit<
  UseGetProps<TypesListCommitResponse[], UsererrorError, ListCommitsQueryParams, ListCommitsPathParams>,
  'path'
> &
  ListCommitsPathParams

export const useListCommits = ({ repo_ref, ...props }: UseListCommitsProps) =>
  useGet<TypesListCommitResponse[], UsererrorError, ListCommitsQueryParams, ListCommitsPathParams>(
    (paramsInPath: ListCommitsPathParams) => `/repos/${paramsInPath.repo_ref}/commits`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface CommitFilesPathParams {
  repo_ref: string
}

export type CommitFilesProps = Omit<
  MutateProps<RepoCommitFilesResponse, UsererrorError, void, OpenapiCommitFilesRequest, CommitFilesPathParams>,
  'path' | 'verb'
> &
  CommitFilesPathParams

export const CommitFiles = ({ repo_ref, ...props }: CommitFilesProps) => (
  <Mutate<RepoCommitFilesResponse, UsererrorError, void, OpenapiCommitFilesRequest, CommitFilesPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/commits`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCommitFilesProps = Omit<
  UseMutateProps<RepoCommitFilesResponse, UsererrorError, void, OpenapiCommitFilesRequest, CommitFilesPathParams>,
  'path' | 'verb'
> &
  CommitFilesPathParams

export const useCommitFiles = ({ repo_ref, ...props }: UseCommitFilesProps) =>
  useMutate<RepoCommitFilesResponse, UsererrorError, void, OpenapiCommitFilesRequest, CommitFilesPathParams>(
    'POST',
    (paramsInPath: CommitFilesPathParams) => `/repos/${paramsInPath.repo_ref}/commits`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface GetCommitPathParams {
  repo_ref: string
  commit_sha: string
}

export type GetCommitProps = Omit<GetProps<TypesCommit, UsererrorError, void, GetCommitPathParams>, 'path'> &
  GetCommitPathParams

export const GetCommit = ({ repo_ref, commit_sha, ...props }: GetCommitProps) => (
  <Get<TypesCommit, UsererrorError, void, GetCommitPathParams>
    path={`/repos/${repo_ref}/commits/${commit_sha}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetCommitProps = Omit<UseGetProps<TypesCommit, UsererrorError, void, GetCommitPathParams>, 'path'> &
  GetCommitPathParams

export const useGetCommit = ({ repo_ref, commit_sha, ...props }: UseGetCommitProps) =>
  useGet<TypesCommit, UsererrorError, void, GetCommitPathParams>(
    (paramsInPath: GetCommitPathParams) => `/repos/${paramsInPath.repo_ref}/commits/${paramsInPath.commit_sha}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, commit_sha }, ...props }
  )

export interface CalculateCommitDivergencePathParams {
  repo_ref: string
}

export type CalculateCommitDivergenceProps = Omit<
  MutateProps<
    RepoCommitDivergence[],
    UsererrorError,
    void,
    OpenapiCalculateCommitDivergenceRequest,
    CalculateCommitDivergencePathParams
  >,
  'path' | 'verb'
> &
  CalculateCommitDivergencePathParams

export const CalculateCommitDivergence = ({ repo_ref, ...props }: CalculateCommitDivergenceProps) => (
  <Mutate<
    RepoCommitDivergence[],
    UsererrorError,
    void,
    OpenapiCalculateCommitDivergenceRequest,
    CalculateCommitDivergencePathParams
  >
    verb="POST"
    path={`/repos/${repo_ref}/commits/calculate-divergence`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCalculateCommitDivergenceProps = Omit<
  UseMutateProps<
    RepoCommitDivergence[],
    UsererrorError,
    void,
    OpenapiCalculateCommitDivergenceRequest,
    CalculateCommitDivergencePathParams
  >,
  'path' | 'verb'
> &
  CalculateCommitDivergencePathParams

export const useCalculateCommitDivergence = ({ repo_ref, ...props }: UseCalculateCommitDivergenceProps) =>
  useMutate<
    RepoCommitDivergence[],
    UsererrorError,
    void,
    OpenapiCalculateCommitDivergenceRequest,
    CalculateCommitDivergencePathParams
  >(
    'POST',
    (paramsInPath: CalculateCommitDivergencePathParams) =>
      `/repos/${paramsInPath.repo_ref}/commits/calculate-divergence`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface GetContentQueryParams {
  /**
   * The git reference (branch / tag / commitID) that will be used to retrieve the data. If no value is provided the default branch of the repository is used.
   */
  git_ref?: string
  /**
   * Indicates whether optional commit information should be included in the response.
   */
  include_commit?: boolean
}

export interface GetContentPathParams {
  repo_ref: string
  path: string
}

export type GetContentProps = Omit<
  GetProps<OpenapiGetContentOutput, UsererrorError, GetContentQueryParams, GetContentPathParams>,
  'path'
> &
  GetContentPathParams

export const GetContent = ({ repo_ref, path, ...props }: GetContentProps) => (
  <Get<OpenapiGetContentOutput, UsererrorError, GetContentQueryParams, GetContentPathParams>
    path={`/repos/${repo_ref}/content/${path}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetContentProps = Omit<
  UseGetProps<OpenapiGetContentOutput, UsererrorError, GetContentQueryParams, GetContentPathParams>,
  'path'
> &
  GetContentPathParams

export const useGetContent = ({ repo_ref, path, ...props }: UseGetContentProps) =>
  useGet<OpenapiGetContentOutput, UsererrorError, GetContentQueryParams, GetContentPathParams>(
    (paramsInPath: GetContentPathParams) => `/repos/${paramsInPath.repo_ref}/content/${paramsInPath.path}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, path }, ...props }
  )

export interface DiffStatsPathParams {
  repo_ref: string
  range: string
}

export type DiffStatsProps = Omit<GetProps<TypesDiffStats, UsererrorError, void, DiffStatsPathParams>, 'path'> &
  DiffStatsPathParams

export const DiffStats = ({ repo_ref, range, ...props }: DiffStatsProps) => (
  <Get<TypesDiffStats, UsererrorError, void, DiffStatsPathParams>
    path={`/repos/${repo_ref}/diff-stats/${range}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDiffStatsProps = Omit<UseGetProps<TypesDiffStats, UsererrorError, void, DiffStatsPathParams>, 'path'> &
  DiffStatsPathParams

export const useDiffStats = ({ repo_ref, range, ...props }: UseDiffStatsProps) =>
  useGet<TypesDiffStats, UsererrorError, void, DiffStatsPathParams>(
    (paramsInPath: DiffStatsPathParams) => `/repos/${paramsInPath.repo_ref}/diff-stats/${paramsInPath.range}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, range }, ...props }
  )

export interface RawDiffPathParams {
  repo_ref: string
  range: string
}

export type RawDiffProps = Omit<GetProps<GitrpcFileDiff[], UsererrorError, void, RawDiffPathParams>, 'path'> &
  RawDiffPathParams

export const RawDiff = ({ repo_ref, range, ...props }: RawDiffProps) => (
  <Get<GitrpcFileDiff[], UsererrorError, void, RawDiffPathParams>
    path={`/repos/${repo_ref}/diff/${range}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseRawDiffProps = Omit<UseGetProps<GitrpcFileDiff[], UsererrorError, void, RawDiffPathParams>, 'path'> &
  RawDiffPathParams

export const useRawDiff = ({ repo_ref, range, ...props }: UseRawDiffProps) =>
  useGet<GitrpcFileDiff[], UsererrorError, void, RawDiffPathParams>(
    (paramsInPath: RawDiffPathParams) => `/repos/${paramsInPath.repo_ref}/diff/${paramsInPath.range}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, range }, ...props }
  )

export interface MergeCheckPathParams {
  repo_ref: string
  range: string
}

export type MergeCheckProps = Omit<
  MutateProps<RepoMergeCheck, UsererrorError, void, void, MergeCheckPathParams>,
  'path' | 'verb'
> &
  MergeCheckPathParams

export const MergeCheck = ({ repo_ref, range, ...props }: MergeCheckProps) => (
  <Mutate<RepoMergeCheck, UsererrorError, void, void, MergeCheckPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/merge-check/${range}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseMergeCheckProps = Omit<
  UseMutateProps<RepoMergeCheck, UsererrorError, void, void, MergeCheckPathParams>,
  'path' | 'verb'
> &
  MergeCheckPathParams

export const useMergeCheck = ({ repo_ref, range, ...props }: UseMergeCheckProps) =>
  useMutate<RepoMergeCheck, UsererrorError, void, void, MergeCheckPathParams>(
    'POST',
    (paramsInPath: MergeCheckPathParams) => `/repos/${paramsInPath.repo_ref}/merge-check/${paramsInPath.range}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, range }, ...props }
  )

export interface MoveRepositoryPathParams {
  repo_ref: string
}

export type MoveRepositoryProps = Omit<
  MutateProps<TypesRepository, UsererrorError, void, OpenapiMoveRepoRequest, MoveRepositoryPathParams>,
  'path' | 'verb'
> &
  MoveRepositoryPathParams

export const MoveRepository = ({ repo_ref, ...props }: MoveRepositoryProps) => (
  <Mutate<TypesRepository, UsererrorError, void, OpenapiMoveRepoRequest, MoveRepositoryPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/move`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseMoveRepositoryProps = Omit<
  UseMutateProps<TypesRepository, UsererrorError, void, OpenapiMoveRepoRequest, MoveRepositoryPathParams>,
  'path' | 'verb'
> &
  MoveRepositoryPathParams

export const useMoveRepository = ({ repo_ref, ...props }: UseMoveRepositoryProps) =>
  useMutate<TypesRepository, UsererrorError, void, OpenapiMoveRepoRequest, MoveRepositoryPathParams>(
    'POST',
    (paramsInPath: MoveRepositoryPathParams) => `/repos/${paramsInPath.repo_ref}/move`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface PathDetailsQueryParams {
  /**
   * The git reference (branch / tag / commitID) that will be used to retrieve the data. If no value is provided the default branch of the repository is used.
   */
  git_ref?: string
}

export interface PathDetailsPathParams {
  repo_ref: string
}

export type PathDetailsProps = Omit<
  MutateProps<
    RepoPathsDetailsOutput,
    UsererrorError,
    PathDetailsQueryParams,
    OpenapiPathsDetailsRequest,
    PathDetailsPathParams
  >,
  'path' | 'verb'
> &
  PathDetailsPathParams

export const PathDetails = ({ repo_ref, ...props }: PathDetailsProps) => (
  <Mutate<
    RepoPathsDetailsOutput,
    UsererrorError,
    PathDetailsQueryParams,
    OpenapiPathsDetailsRequest,
    PathDetailsPathParams
  >
    verb="POST"
    path={`/repos/${repo_ref}/path-details`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UsePathDetailsProps = Omit<
  UseMutateProps<
    RepoPathsDetailsOutput,
    UsererrorError,
    PathDetailsQueryParams,
    OpenapiPathsDetailsRequest,
    PathDetailsPathParams
  >,
  'path' | 'verb'
> &
  PathDetailsPathParams

export const usePathDetails = ({ repo_ref, ...props }: UsePathDetailsProps) =>
  useMutate<
    RepoPathsDetailsOutput,
    UsererrorError,
    PathDetailsQueryParams,
    OpenapiPathsDetailsRequest,
    PathDetailsPathParams
  >('POST', (paramsInPath: PathDetailsPathParams) => `/repos/${paramsInPath.repo_ref}/path-details`, {
    base: getConfig('code/api/v1'),
    pathParams: { repo_ref },
    ...props
  })

export interface ListRepositoryPathsQueryParams {
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListRepositoryPathsPathParams {
  repo_ref: string
}

export type ListRepositoryPathsProps = Omit<
  GetProps<TypesPath[], UsererrorError, ListRepositoryPathsQueryParams, ListRepositoryPathsPathParams>,
  'path'
> &
  ListRepositoryPathsPathParams

export const ListRepositoryPaths = ({ repo_ref, ...props }: ListRepositoryPathsProps) => (
  <Get<TypesPath[], UsererrorError, ListRepositoryPathsQueryParams, ListRepositoryPathsPathParams>
    path={`/repos/${repo_ref}/paths`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListRepositoryPathsProps = Omit<
  UseGetProps<TypesPath[], UsererrorError, ListRepositoryPathsQueryParams, ListRepositoryPathsPathParams>,
  'path'
> &
  ListRepositoryPathsPathParams

export const useListRepositoryPaths = ({ repo_ref, ...props }: UseListRepositoryPathsProps) =>
  useGet<TypesPath[], UsererrorError, ListRepositoryPathsQueryParams, ListRepositoryPathsPathParams>(
    (paramsInPath: ListRepositoryPathsPathParams) => `/repos/${paramsInPath.repo_ref}/paths`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface CreateRepositoryPathPathParams {
  repo_ref: string
}

export type CreateRepositoryPathProps = Omit<
  MutateProps<TypesPath, UsererrorError, void, OpenapiCreateRepoPathRequest, CreateRepositoryPathPathParams>,
  'path' | 'verb'
> &
  CreateRepositoryPathPathParams

export const CreateRepositoryPath = ({ repo_ref, ...props }: CreateRepositoryPathProps) => (
  <Mutate<TypesPath, UsererrorError, void, OpenapiCreateRepoPathRequest, CreateRepositoryPathPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/paths`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateRepositoryPathProps = Omit<
  UseMutateProps<TypesPath, UsererrorError, void, OpenapiCreateRepoPathRequest, CreateRepositoryPathPathParams>,
  'path' | 'verb'
> &
  CreateRepositoryPathPathParams

export const useCreateRepositoryPath = ({ repo_ref, ...props }: UseCreateRepositoryPathProps) =>
  useMutate<TypesPath, UsererrorError, void, OpenapiCreateRepoPathRequest, CreateRepositoryPathPathParams>(
    'POST',
    (paramsInPath: CreateRepositoryPathPathParams) => `/repos/${paramsInPath.repo_ref}/paths`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface DeleteRepositoryPathPathParams {
  repo_ref: string
}

export type DeleteRepositoryPathProps = Omit<
  MutateProps<void, UsererrorError, void, string, DeleteRepositoryPathPathParams>,
  'path' | 'verb'
> &
  DeleteRepositoryPathPathParams

export const DeleteRepositoryPath = ({ repo_ref, ...props }: DeleteRepositoryPathProps) => (
  <Mutate<void, UsererrorError, void, string, DeleteRepositoryPathPathParams>
    verb="DELETE"
    path={`/repos/${repo_ref}/paths`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteRepositoryPathProps = Omit<
  UseMutateProps<void, UsererrorError, void, string, DeleteRepositoryPathPathParams>,
  'path' | 'verb'
> &
  DeleteRepositoryPathPathParams

export const useDeleteRepositoryPath = ({ repo_ref, ...props }: UseDeleteRepositoryPathProps) =>
  useMutate<void, UsererrorError, void, string, DeleteRepositoryPathPathParams>(
    'DELETE',
    (paramsInPath: DeleteRepositoryPathPathParams) => `/repos/${paramsInPath.repo_ref}/paths`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface ListPipelinesQueryParams {
  /**
   * The substring which is used to filter the repositories by their path name.
   */
  query?: string
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
  /**
   * Whether to fetch latest build information for each pipeline.
   */
  latest?: boolean
}

export interface ListPipelinesPathParams {
  repo_ref: string
}

export type ListPipelinesProps = Omit<
  GetProps<TypesPipeline[], UsererrorError, ListPipelinesQueryParams, ListPipelinesPathParams>,
  'path'
> &
  ListPipelinesPathParams

export const ListPipelines = ({ repo_ref, ...props }: ListPipelinesProps) => (
  <Get<TypesPipeline[], UsererrorError, ListPipelinesQueryParams, ListPipelinesPathParams>
    path={`/repos/${repo_ref}/pipelines`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListPipelinesProps = Omit<
  UseGetProps<TypesPipeline[], UsererrorError, ListPipelinesQueryParams, ListPipelinesPathParams>,
  'path'
> &
  ListPipelinesPathParams

export const useListPipelines = ({ repo_ref, ...props }: UseListPipelinesProps) =>
  useGet<TypesPipeline[], UsererrorError, ListPipelinesQueryParams, ListPipelinesPathParams>(
    (paramsInPath: ListPipelinesPathParams) => `/repos/${paramsInPath.repo_ref}/pipelines`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface CreatePipelinePathParams {
  repo_ref: string
}

export type CreatePipelineProps = Omit<
  MutateProps<TypesPipeline, UsererrorError, void, OpenapiCreatePipelineRequest, CreatePipelinePathParams>,
  'path' | 'verb'
> &
  CreatePipelinePathParams

export const CreatePipeline = ({ repo_ref, ...props }: CreatePipelineProps) => (
  <Mutate<TypesPipeline, UsererrorError, void, OpenapiCreatePipelineRequest, CreatePipelinePathParams>
    verb="POST"
    path={`/repos/${repo_ref}/pipelines`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreatePipelineProps = Omit<
  UseMutateProps<TypesPipeline, UsererrorError, void, OpenapiCreatePipelineRequest, CreatePipelinePathParams>,
  'path' | 'verb'
> &
  CreatePipelinePathParams

export const useCreatePipeline = ({ repo_ref, ...props }: UseCreatePipelineProps) =>
  useMutate<TypesPipeline, UsererrorError, void, OpenapiCreatePipelineRequest, CreatePipelinePathParams>(
    'POST',
    (paramsInPath: CreatePipelinePathParams) => `/repos/${paramsInPath.repo_ref}/pipelines`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface DeletePipelinePathParams {
  repo_ref: string
}

export type DeletePipelineProps = Omit<
  MutateProps<void, UsererrorError, void, string, DeletePipelinePathParams>,
  'path' | 'verb'
> &
  DeletePipelinePathParams

export const DeletePipeline = ({ repo_ref, ...props }: DeletePipelineProps) => (
  <Mutate<void, UsererrorError, void, string, DeletePipelinePathParams>
    verb="DELETE"
    path={`/repos/${repo_ref}/pipelines`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeletePipelineProps = Omit<
  UseMutateProps<void, UsererrorError, void, string, DeletePipelinePathParams>,
  'path' | 'verb'
> &
  DeletePipelinePathParams

export const useDeletePipeline = ({ repo_ref, ...props }: UseDeletePipelineProps) =>
  useMutate<void, UsererrorError, void, string, DeletePipelinePathParams>(
    'DELETE',
    (paramsInPath: DeletePipelinePathParams) => `/repos/${paramsInPath.repo_ref}/pipelines`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface FindPipelinePathParams {
  repo_ref: string
  pipeline_uid: string
}

export type FindPipelineProps = Omit<GetProps<TypesPipeline, UsererrorError, void, FindPipelinePathParams>, 'path'> &
  FindPipelinePathParams

export const FindPipeline = ({ repo_ref, pipeline_uid, ...props }: FindPipelineProps) => (
  <Get<TypesPipeline, UsererrorError, void, FindPipelinePathParams>
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseFindPipelineProps = Omit<
  UseGetProps<TypesPipeline, UsererrorError, void, FindPipelinePathParams>,
  'path'
> &
  FindPipelinePathParams

export const useFindPipeline = ({ repo_ref, pipeline_uid, ...props }: UseFindPipelineProps) =>
  useGet<TypesPipeline, UsererrorError, void, FindPipelinePathParams>(
    (paramsInPath: FindPipelinePathParams) => `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid }, ...props }
  )

export interface UpdatePipelinePathParams {
  repo_ref: string
  pipeline_uid: string
}

export type UpdatePipelineProps = Omit<
  MutateProps<TypesPipeline, UsererrorError, void, OpenapiUpdatePipelineRequest, UpdatePipelinePathParams>,
  'path' | 'verb'
> &
  UpdatePipelinePathParams

export const UpdatePipeline = ({ repo_ref, pipeline_uid, ...props }: UpdatePipelineProps) => (
  <Mutate<TypesPipeline, UsererrorError, void, OpenapiUpdatePipelineRequest, UpdatePipelinePathParams>
    verb="PATCH"
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdatePipelineProps = Omit<
  UseMutateProps<TypesPipeline, UsererrorError, void, OpenapiUpdatePipelineRequest, UpdatePipelinePathParams>,
  'path' | 'verb'
> &
  UpdatePipelinePathParams

export const useUpdatePipeline = ({ repo_ref, pipeline_uid, ...props }: UseUpdatePipelineProps) =>
  useMutate<TypesPipeline, UsererrorError, void, OpenapiUpdatePipelineRequest, UpdatePipelinePathParams>(
    'PATCH',
    (paramsInPath: UpdatePipelinePathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid }, ...props }
  )

export interface ListExecutionsQueryParams {
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListExecutionsPathParams {
  repo_ref: string
  pipeline_uid: string
}

export type ListExecutionsProps = Omit<
  GetProps<TypesExecution[], UsererrorError, ListExecutionsQueryParams, ListExecutionsPathParams>,
  'path'
> &
  ListExecutionsPathParams

export const ListExecutions = ({ repo_ref, pipeline_uid, ...props }: ListExecutionsProps) => (
  <Get<TypesExecution[], UsererrorError, ListExecutionsQueryParams, ListExecutionsPathParams>
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/executions`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListExecutionsProps = Omit<
  UseGetProps<TypesExecution[], UsererrorError, ListExecutionsQueryParams, ListExecutionsPathParams>,
  'path'
> &
  ListExecutionsPathParams

export const useListExecutions = ({ repo_ref, pipeline_uid, ...props }: UseListExecutionsProps) =>
  useGet<TypesExecution[], UsererrorError, ListExecutionsQueryParams, ListExecutionsPathParams>(
    (paramsInPath: ListExecutionsPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/executions`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid }, ...props }
  )

export interface CreateExecutionPathParams {
  repo_ref: string
  pipeline_uid: string
}

export type CreateExecutionProps = Omit<
  MutateProps<TypesExecution, UsererrorError, void, OpenapiCreateExecutionRequest, CreateExecutionPathParams>,
  'path' | 'verb'
> &
  CreateExecutionPathParams

export const CreateExecution = ({ repo_ref, pipeline_uid, ...props }: CreateExecutionProps) => (
  <Mutate<TypesExecution, UsererrorError, void, OpenapiCreateExecutionRequest, CreateExecutionPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/executions`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateExecutionProps = Omit<
  UseMutateProps<TypesExecution, UsererrorError, void, OpenapiCreateExecutionRequest, CreateExecutionPathParams>,
  'path' | 'verb'
> &
  CreateExecutionPathParams

export const useCreateExecution = ({ repo_ref, pipeline_uid, ...props }: UseCreateExecutionProps) =>
  useMutate<TypesExecution, UsererrorError, void, OpenapiCreateExecutionRequest, CreateExecutionPathParams>(
    'POST',
    (paramsInPath: CreateExecutionPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/executions`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid }, ...props }
  )

export interface DeleteExecutionPathParams {
  repo_ref: string
  pipeline_uid: string
}

export type DeleteExecutionProps = Omit<
  MutateProps<void, UsererrorError, void, string, DeleteExecutionPathParams>,
  'path' | 'verb'
> &
  DeleteExecutionPathParams

export const DeleteExecution = ({ repo_ref, pipeline_uid, ...props }: DeleteExecutionProps) => (
  <Mutate<void, UsererrorError, void, string, DeleteExecutionPathParams>
    verb="DELETE"
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/executions`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteExecutionProps = Omit<
  UseMutateProps<void, UsererrorError, void, string, DeleteExecutionPathParams>,
  'path' | 'verb'
> &
  DeleteExecutionPathParams

export const useDeleteExecution = ({ repo_ref, pipeline_uid, ...props }: UseDeleteExecutionProps) =>
  useMutate<void, UsererrorError, void, string, DeleteExecutionPathParams>(
    'DELETE',
    (paramsInPath: DeleteExecutionPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/executions`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid }, ...props }
  )

export interface FindExecutionPathParams {
  repo_ref: string
  pipeline_uid: string
  execution_number: string
}

export type FindExecutionProps = Omit<GetProps<TypesExecution, UsererrorError, void, FindExecutionPathParams>, 'path'> &
  FindExecutionPathParams

export const FindExecution = ({ repo_ref, pipeline_uid, execution_number, ...props }: FindExecutionProps) => (
  <Get<TypesExecution, UsererrorError, void, FindExecutionPathParams>
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/executions/${execution_number}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseFindExecutionProps = Omit<
  UseGetProps<TypesExecution, UsererrorError, void, FindExecutionPathParams>,
  'path'
> &
  FindExecutionPathParams

export const useFindExecution = ({ repo_ref, pipeline_uid, execution_number, ...props }: UseFindExecutionProps) =>
  useGet<TypesExecution, UsererrorError, void, FindExecutionPathParams>(
    (paramsInPath: FindExecutionPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/executions/${paramsInPath.execution_number}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid, execution_number }, ...props }
  )

export interface UpdateExecutionPathParams {
  repo_ref: string
  pipeline_uid: string
  execution_number: string
}

export type UpdateExecutionProps = Omit<
  MutateProps<TypesExecution, UsererrorError, void, OpenapiUpdateExecutionRequest, UpdateExecutionPathParams>,
  'path' | 'verb'
> &
  UpdateExecutionPathParams

export const UpdateExecution = ({ repo_ref, pipeline_uid, execution_number, ...props }: UpdateExecutionProps) => (
  <Mutate<TypesExecution, UsererrorError, void, OpenapiUpdateExecutionRequest, UpdateExecutionPathParams>
    verb="PATCH"
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/executions/${execution_number}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateExecutionProps = Omit<
  UseMutateProps<TypesExecution, UsererrorError, void, OpenapiUpdateExecutionRequest, UpdateExecutionPathParams>,
  'path' | 'verb'
> &
  UpdateExecutionPathParams

export const useUpdateExecution = ({ repo_ref, pipeline_uid, execution_number, ...props }: UseUpdateExecutionProps) =>
  useMutate<TypesExecution, UsererrorError, void, OpenapiUpdateExecutionRequest, UpdateExecutionPathParams>(
    'PATCH',
    (paramsInPath: UpdateExecutionPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/executions/${paramsInPath.execution_number}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid, execution_number }, ...props }
  )

export interface ViewLogsPathParams {
  repo_ref: string
  pipeline_uid: string
  execution_number: string
  stage_number: string
  step_number: string
}

export type ViewLogsProps = Omit<GetProps<void, UsererrorError, void, ViewLogsPathParams>, 'path'> & ViewLogsPathParams

export const ViewLogs = ({
  repo_ref,
  pipeline_uid,
  execution_number,
  stage_number,
  step_number,
  ...props
}: ViewLogsProps) => (
  <Get<void, UsererrorError, void, ViewLogsPathParams>
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/executions/${execution_number}/logs/${stage_number}/${step_number}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseViewLogsProps = Omit<UseGetProps<void, UsererrorError, void, ViewLogsPathParams>, 'path'> &
  ViewLogsPathParams

export const useViewLogs = ({
  repo_ref,
  pipeline_uid,
  execution_number,
  stage_number,
  step_number,
  ...props
}: UseViewLogsProps) =>
  useGet<void, UsererrorError, void, ViewLogsPathParams>(
    (paramsInPath: ViewLogsPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/executions/${paramsInPath.execution_number}/logs/${paramsInPath.stage_number}/${paramsInPath.step_number}`,
    {
      base: getConfig('code/api/v1'),
      pathParams: { repo_ref, pipeline_uid, execution_number, stage_number, step_number },
      ...props
    }
  )

export interface ListTriggersQueryParams {
  /**
   * The substring which is used to filter the repositories by their path name.
   */
  query?: string
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListTriggersPathParams {
  repo_ref: string
  pipeline_uid: string
}

export type ListTriggersProps = Omit<
  GetProps<TypesTrigger[], UsererrorError, ListTriggersQueryParams, ListTriggersPathParams>,
  'path'
> &
  ListTriggersPathParams

export const ListTriggers = ({ repo_ref, pipeline_uid, ...props }: ListTriggersProps) => (
  <Get<TypesTrigger[], UsererrorError, ListTriggersQueryParams, ListTriggersPathParams>
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/triggers`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListTriggersProps = Omit<
  UseGetProps<TypesTrigger[], UsererrorError, ListTriggersQueryParams, ListTriggersPathParams>,
  'path'
> &
  ListTriggersPathParams

export const useListTriggers = ({ repo_ref, pipeline_uid, ...props }: UseListTriggersProps) =>
  useGet<TypesTrigger[], UsererrorError, ListTriggersQueryParams, ListTriggersPathParams>(
    (paramsInPath: ListTriggersPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/triggers`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid }, ...props }
  )

export interface CreateTriggerPathParams {
  repo_ref: string
  pipeline_uid: string
}

export type CreateTriggerProps = Omit<
  MutateProps<TypesTrigger, UsererrorError, void, OpenapiCreateTriggerRequest, CreateTriggerPathParams>,
  'path' | 'verb'
> &
  CreateTriggerPathParams

export const CreateTrigger = ({ repo_ref, pipeline_uid, ...props }: CreateTriggerProps) => (
  <Mutate<TypesTrigger, UsererrorError, void, OpenapiCreateTriggerRequest, CreateTriggerPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/triggers`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateTriggerProps = Omit<
  UseMutateProps<TypesTrigger, UsererrorError, void, OpenapiCreateTriggerRequest, CreateTriggerPathParams>,
  'path' | 'verb'
> &
  CreateTriggerPathParams

export const useCreateTrigger = ({ repo_ref, pipeline_uid, ...props }: UseCreateTriggerProps) =>
  useMutate<TypesTrigger, UsererrorError, void, OpenapiCreateTriggerRequest, CreateTriggerPathParams>(
    'POST',
    (paramsInPath: CreateTriggerPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/triggers`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid }, ...props }
  )

export interface DeleteTriggerPathParams {
  repo_ref: string
  pipeline_uid: string
}

export type DeleteTriggerProps = Omit<
  MutateProps<void, UsererrorError, void, string, DeleteTriggerPathParams>,
  'path' | 'verb'
> &
  DeleteTriggerPathParams

export const DeleteTrigger = ({ repo_ref, pipeline_uid, ...props }: DeleteTriggerProps) => (
  <Mutate<void, UsererrorError, void, string, DeleteTriggerPathParams>
    verb="DELETE"
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/triggers`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteTriggerProps = Omit<
  UseMutateProps<void, UsererrorError, void, string, DeleteTriggerPathParams>,
  'path' | 'verb'
> &
  DeleteTriggerPathParams

export const useDeleteTrigger = ({ repo_ref, pipeline_uid, ...props }: UseDeleteTriggerProps) =>
  useMutate<void, UsererrorError, void, string, DeleteTriggerPathParams>(
    'DELETE',
    (paramsInPath: DeleteTriggerPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/triggers`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid }, ...props }
  )

export interface FindTriggerPathParams {
  repo_ref: string
  pipeline_uid: string
  trigger_uid: string
}

export type FindTriggerProps = Omit<GetProps<TypesTrigger, UsererrorError, void, FindTriggerPathParams>, 'path'> &
  FindTriggerPathParams

export const FindTrigger = ({ repo_ref, pipeline_uid, trigger_uid, ...props }: FindTriggerProps) => (
  <Get<TypesTrigger, UsererrorError, void, FindTriggerPathParams>
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/triggers/${trigger_uid}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseFindTriggerProps = Omit<UseGetProps<TypesTrigger, UsererrorError, void, FindTriggerPathParams>, 'path'> &
  FindTriggerPathParams

export const useFindTrigger = ({ repo_ref, pipeline_uid, trigger_uid, ...props }: UseFindTriggerProps) =>
  useGet<TypesTrigger, UsererrorError, void, FindTriggerPathParams>(
    (paramsInPath: FindTriggerPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/triggers/${paramsInPath.trigger_uid}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid, trigger_uid }, ...props }
  )

export interface UpdateTriggerPathParams {
  repo_ref: string
  pipeline_uid: string
  trigger_uid: string
}

export type UpdateTriggerProps = Omit<
  MutateProps<TypesTrigger, UsererrorError, void, OpenapiUpdateTriggerRequest, UpdateTriggerPathParams>,
  'path' | 'verb'
> &
  UpdateTriggerPathParams

export const UpdateTrigger = ({ repo_ref, pipeline_uid, trigger_uid, ...props }: UpdateTriggerProps) => (
  <Mutate<TypesTrigger, UsererrorError, void, OpenapiUpdateTriggerRequest, UpdateTriggerPathParams>
    verb="PATCH"
    path={`/repos/${repo_ref}/pipelines/${pipeline_uid}/triggers/${trigger_uid}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateTriggerProps = Omit<
  UseMutateProps<TypesTrigger, UsererrorError, void, OpenapiUpdateTriggerRequest, UpdateTriggerPathParams>,
  'path' | 'verb'
> &
  UpdateTriggerPathParams

export const useUpdateTrigger = ({ repo_ref, pipeline_uid, trigger_uid, ...props }: UseUpdateTriggerProps) =>
  useMutate<TypesTrigger, UsererrorError, void, OpenapiUpdateTriggerRequest, UpdateTriggerPathParams>(
    'PATCH',
    (paramsInPath: UpdateTriggerPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pipelines/${paramsInPath.pipeline_uid}/triggers/${paramsInPath.trigger_uid}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pipeline_uid, trigger_uid }, ...props }
  )

export interface ListPullReqQueryParams {
  /**
   * The state of the pull requests to include in the result.
   */
  state?: ('closed' | 'merged' | 'open')[]
  /**
   * Source repository ref of the pull requests.
   */
  source_repo_ref?: string
  /**
   * Source branch of the pull requests.
   */
  source_branch?: string
  /**
   * Target branch of the pull requests.
   */
  target_branch?: string
  /**
   * The substring by which the pull requests are filtered.
   */
  query?: string
  /**
   * The principal ID who created pull requests.
   */
  created_by?: number
  /**
   * The order of the output.
   */
  order?: 'asc' | 'desc'
  /**
   * The data by which the pull requests are sorted.
   */
  sort?: 'created' | 'edited' | 'merged' | 'number'
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListPullReqPathParams {
  repo_ref: string
}

export type ListPullReqProps = Omit<
  GetProps<TypesPullReq[], UsererrorError, ListPullReqQueryParams, ListPullReqPathParams>,
  'path'
> &
  ListPullReqPathParams

export const ListPullReq = ({ repo_ref, ...props }: ListPullReqProps) => (
  <Get<TypesPullReq[], UsererrorError, ListPullReqQueryParams, ListPullReqPathParams>
    path={`/repos/${repo_ref}/pullreq`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListPullReqProps = Omit<
  UseGetProps<TypesPullReq[], UsererrorError, ListPullReqQueryParams, ListPullReqPathParams>,
  'path'
> &
  ListPullReqPathParams

export const useListPullReq = ({ repo_ref, ...props }: UseListPullReqProps) =>
  useGet<TypesPullReq[], UsererrorError, ListPullReqQueryParams, ListPullReqPathParams>(
    (paramsInPath: ListPullReqPathParams) => `/repos/${paramsInPath.repo_ref}/pullreq`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface CreatePullReqPathParams {
  repo_ref: string
}

export type CreatePullReqProps = Omit<
  MutateProps<TypesPullReq, UsererrorError, void, OpenapiCreatePullReqRequest, CreatePullReqPathParams>,
  'path' | 'verb'
> &
  CreatePullReqPathParams

export const CreatePullReq = ({ repo_ref, ...props }: CreatePullReqProps) => (
  <Mutate<TypesPullReq, UsererrorError, void, OpenapiCreatePullReqRequest, CreatePullReqPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/pullreq`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreatePullReqProps = Omit<
  UseMutateProps<TypesPullReq, UsererrorError, void, OpenapiCreatePullReqRequest, CreatePullReqPathParams>,
  'path' | 'verb'
> &
  CreatePullReqPathParams

export const useCreatePullReq = ({ repo_ref, ...props }: UseCreatePullReqProps) =>
  useMutate<TypesPullReq, UsererrorError, void, OpenapiCreatePullReqRequest, CreatePullReqPathParams>(
    'POST',
    (paramsInPath: CreatePullReqPathParams) => `/repos/${paramsInPath.repo_ref}/pullreq`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface GetPullReqPathParams {
  repo_ref: string
  pullreq_number: number
}

export type GetPullReqProps = Omit<GetProps<TypesPullReq, UsererrorError, void, GetPullReqPathParams>, 'path'> &
  GetPullReqPathParams

export const GetPullReq = ({ repo_ref, pullreq_number, ...props }: GetPullReqProps) => (
  <Get<TypesPullReq, UsererrorError, void, GetPullReqPathParams>
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetPullReqProps = Omit<UseGetProps<TypesPullReq, UsererrorError, void, GetPullReqPathParams>, 'path'> &
  GetPullReqPathParams

export const useGetPullReq = ({ repo_ref, pullreq_number, ...props }: UseGetPullReqProps) =>
  useGet<TypesPullReq, UsererrorError, void, GetPullReqPathParams>(
    (paramsInPath: GetPullReqPathParams) => `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface UpdatePullReqPathParams {
  repo_ref: string
  pullreq_number: number
}

export type UpdatePullReqProps = Omit<
  MutateProps<TypesPullReq, UsererrorError, void, OpenapiUpdatePullReqRequest, UpdatePullReqPathParams>,
  'path' | 'verb'
> &
  UpdatePullReqPathParams

export const UpdatePullReq = ({ repo_ref, pullreq_number, ...props }: UpdatePullReqProps) => (
  <Mutate<TypesPullReq, UsererrorError, void, OpenapiUpdatePullReqRequest, UpdatePullReqPathParams>
    verb="PATCH"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdatePullReqProps = Omit<
  UseMutateProps<TypesPullReq, UsererrorError, void, OpenapiUpdatePullReqRequest, UpdatePullReqPathParams>,
  'path' | 'verb'
> &
  UpdatePullReqPathParams

export const useUpdatePullReq = ({ repo_ref, pullreq_number, ...props }: UseUpdatePullReqProps) =>
  useMutate<TypesPullReq, UsererrorError, void, OpenapiUpdatePullReqRequest, UpdatePullReqPathParams>(
    'PATCH',
    (paramsInPath: UpdatePullReqPathParams) => `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface ListPullReqActivitiesQueryParams {
  /**
   * The kind of the pull request activity to include in the result.
   */
  kind?: ('change-comment' | 'comment' | 'system')[]
  /**
   * The type of the pull request activity to include in the result.
   */
  type?: (
    | 'branch-delete'
    | 'branch-update'
    | 'code-comment'
    | 'comment'
    | 'merge'
    | 'review-submit'
    | 'state-change'
    | 'title-change'
  )[]
  /**
   * The result should contain only entries created at and after this timestamp (unix millis).
   */
  after?: number
  /**
   * The result should contain only entries created before this timestamp (unix millis).
   */
  before?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListPullReqActivitiesPathParams {
  repo_ref: string
  pullreq_number: number
}

export type ListPullReqActivitiesProps = Omit<
  GetProps<TypesPullReqActivity[], UsererrorError, ListPullReqActivitiesQueryParams, ListPullReqActivitiesPathParams>,
  'path'
> &
  ListPullReqActivitiesPathParams

export const ListPullReqActivities = ({ repo_ref, pullreq_number, ...props }: ListPullReqActivitiesProps) => (
  <Get<TypesPullReqActivity[], UsererrorError, ListPullReqActivitiesQueryParams, ListPullReqActivitiesPathParams>
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/activities`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListPullReqActivitiesProps = Omit<
  UseGetProps<
    TypesPullReqActivity[],
    UsererrorError,
    ListPullReqActivitiesQueryParams,
    ListPullReqActivitiesPathParams
  >,
  'path'
> &
  ListPullReqActivitiesPathParams

export const useListPullReqActivities = ({ repo_ref, pullreq_number, ...props }: UseListPullReqActivitiesProps) =>
  useGet<TypesPullReqActivity[], UsererrorError, ListPullReqActivitiesQueryParams, ListPullReqActivitiesPathParams>(
    (paramsInPath: ListPullReqActivitiesPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/activities`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface CommentCreatePullReqPathParams {
  repo_ref: string
  pullreq_number: number
}

export type CommentCreatePullReqProps = Omit<
  MutateProps<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentCreatePullReqRequest,
    CommentCreatePullReqPathParams
  >,
  'path' | 'verb'
> &
  CommentCreatePullReqPathParams

export const CommentCreatePullReq = ({ repo_ref, pullreq_number, ...props }: CommentCreatePullReqProps) => (
  <Mutate<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentCreatePullReqRequest,
    CommentCreatePullReqPathParams
  >
    verb="POST"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/comments`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCommentCreatePullReqProps = Omit<
  UseMutateProps<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentCreatePullReqRequest,
    CommentCreatePullReqPathParams
  >,
  'path' | 'verb'
> &
  CommentCreatePullReqPathParams

export const useCommentCreatePullReq = ({ repo_ref, pullreq_number, ...props }: UseCommentCreatePullReqProps) =>
  useMutate<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentCreatePullReqRequest,
    CommentCreatePullReqPathParams
  >(
    'POST',
    (paramsInPath: CommentCreatePullReqPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/comments`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface CommentDeletePullReqPathParams {
  repo_ref: string
  pullreq_number: number
}

export type CommentDeletePullReqProps = Omit<
  MutateProps<void, UsererrorError, void, number, CommentDeletePullReqPathParams>,
  'path' | 'verb'
> &
  CommentDeletePullReqPathParams

export const CommentDeletePullReq = ({ repo_ref, pullreq_number, ...props }: CommentDeletePullReqProps) => (
  <Mutate<void, UsererrorError, void, number, CommentDeletePullReqPathParams>
    verb="DELETE"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/comments`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCommentDeletePullReqProps = Omit<
  UseMutateProps<void, UsererrorError, void, number, CommentDeletePullReqPathParams>,
  'path' | 'verb'
> &
  CommentDeletePullReqPathParams

export const useCommentDeletePullReq = ({ repo_ref, pullreq_number, ...props }: UseCommentDeletePullReqProps) =>
  useMutate<void, UsererrorError, void, number, CommentDeletePullReqPathParams>(
    'DELETE',
    (paramsInPath: CommentDeletePullReqPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/comments`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface CommentUpdatePullReqPathParams {
  repo_ref: string
  pullreq_number: number
  pullreq_comment_id: number
}

export type CommentUpdatePullReqProps = Omit<
  MutateProps<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentUpdatePullReqRequest,
    CommentUpdatePullReqPathParams
  >,
  'path' | 'verb'
> &
  CommentUpdatePullReqPathParams

export const CommentUpdatePullReq = ({
  repo_ref,
  pullreq_number,
  pullreq_comment_id,
  ...props
}: CommentUpdatePullReqProps) => (
  <Mutate<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentUpdatePullReqRequest,
    CommentUpdatePullReqPathParams
  >
    verb="PATCH"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/comments/${pullreq_comment_id}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCommentUpdatePullReqProps = Omit<
  UseMutateProps<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentUpdatePullReqRequest,
    CommentUpdatePullReqPathParams
  >,
  'path' | 'verb'
> &
  CommentUpdatePullReqPathParams

export const useCommentUpdatePullReq = ({
  repo_ref,
  pullreq_number,
  pullreq_comment_id,
  ...props
}: UseCommentUpdatePullReqProps) =>
  useMutate<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentUpdatePullReqRequest,
    CommentUpdatePullReqPathParams
  >(
    'PATCH',
    (paramsInPath: CommentUpdatePullReqPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/comments/${paramsInPath.pullreq_comment_id}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number, pullreq_comment_id }, ...props }
  )

export interface CommentStatusPullReqPathParams {
  repo_ref: string
  pullreq_number: number
  pullreq_comment_id: number
}

export type CommentStatusPullReqProps = Omit<
  MutateProps<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentStatusPullReqRequest,
    CommentStatusPullReqPathParams
  >,
  'path' | 'verb'
> &
  CommentStatusPullReqPathParams

export const CommentStatusPullReq = ({
  repo_ref,
  pullreq_number,
  pullreq_comment_id,
  ...props
}: CommentStatusPullReqProps) => (
  <Mutate<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentStatusPullReqRequest,
    CommentStatusPullReqPathParams
  >
    verb="PUT"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/comments/${pullreq_comment_id}/status`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCommentStatusPullReqProps = Omit<
  UseMutateProps<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentStatusPullReqRequest,
    CommentStatusPullReqPathParams
  >,
  'path' | 'verb'
> &
  CommentStatusPullReqPathParams

export const useCommentStatusPullReq = ({
  repo_ref,
  pullreq_number,
  pullreq_comment_id,
  ...props
}: UseCommentStatusPullReqProps) =>
  useMutate<
    TypesPullReqActivity,
    UsererrorError,
    void,
    OpenapiCommentStatusPullReqRequest,
    CommentStatusPullReqPathParams
  >(
    'PUT',
    (paramsInPath: CommentStatusPullReqPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/comments/${paramsInPath.pullreq_comment_id}/status`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number, pullreq_comment_id }, ...props }
  )

export interface ListPullReqCommitsQueryParams {
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListPullReqCommitsPathParams {
  repo_ref: string
  pullreq_number: number
}

export type ListPullReqCommitsProps = Omit<
  GetProps<TypesCommit[], UsererrorError, ListPullReqCommitsQueryParams, ListPullReqCommitsPathParams>,
  'path'
> &
  ListPullReqCommitsPathParams

export const ListPullReqCommits = ({ repo_ref, pullreq_number, ...props }: ListPullReqCommitsProps) => (
  <Get<TypesCommit[], UsererrorError, ListPullReqCommitsQueryParams, ListPullReqCommitsPathParams>
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/commits`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListPullReqCommitsProps = Omit<
  UseGetProps<TypesCommit[], UsererrorError, ListPullReqCommitsQueryParams, ListPullReqCommitsPathParams>,
  'path'
> &
  ListPullReqCommitsPathParams

export const useListPullReqCommits = ({ repo_ref, pullreq_number, ...props }: UseListPullReqCommitsProps) =>
  useGet<TypesCommit[], UsererrorError, ListPullReqCommitsQueryParams, ListPullReqCommitsPathParams>(
    (paramsInPath: ListPullReqCommitsPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/commits`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface MergePullReqOpPathParams {
  repo_ref: string
  pullreq_number: number
}

export type MergePullReqOpProps = Omit<
  MutateProps<TypesMergeResponse, UsererrorError, void, OpenapiMergePullReq, MergePullReqOpPathParams>,
  'path' | 'verb'
> &
  MergePullReqOpPathParams

export const MergePullReqOp = ({ repo_ref, pullreq_number, ...props }: MergePullReqOpProps) => (
  <Mutate<TypesMergeResponse, UsererrorError, void, OpenapiMergePullReq, MergePullReqOpPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/merge`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseMergePullReqOpProps = Omit<
  UseMutateProps<TypesMergeResponse, UsererrorError, void, OpenapiMergePullReq, MergePullReqOpPathParams>,
  'path' | 'verb'
> &
  MergePullReqOpPathParams

export const useMergePullReqOp = ({ repo_ref, pullreq_number, ...props }: UseMergePullReqOpProps) =>
  useMutate<TypesMergeResponse, UsererrorError, void, OpenapiMergePullReq, MergePullReqOpPathParams>(
    'POST',
    (paramsInPath: MergePullReqOpPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/merge`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface PullReqMetaDataPathParams {
  repo_ref: string
  pullreq_number: number
}

export type PullReqMetaDataProps = Omit<
  GetProps<TypesPullReqStats, UsererrorError, void, PullReqMetaDataPathParams>,
  'path'
> &
  PullReqMetaDataPathParams

export const PullReqMetaData = ({ repo_ref, pullreq_number, ...props }: PullReqMetaDataProps) => (
  <Get<TypesPullReqStats, UsererrorError, void, PullReqMetaDataPathParams>
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/metadata`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UsePullReqMetaDataProps = Omit<
  UseGetProps<TypesPullReqStats, UsererrorError, void, PullReqMetaDataPathParams>,
  'path'
> &
  PullReqMetaDataPathParams

export const usePullReqMetaData = ({ repo_ref, pullreq_number, ...props }: UsePullReqMetaDataProps) =>
  useGet<TypesPullReqStats, UsererrorError, void, PullReqMetaDataPathParams>(
    (paramsInPath: PullReqMetaDataPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/metadata`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface ReviewerListPullReqPathParams {
  repo_ref: string
  pullreq_number: number
}

export type ReviewerListPullReqProps = Omit<
  GetProps<TypesPullReqReviewer[], UsererrorError, void, ReviewerListPullReqPathParams>,
  'path'
> &
  ReviewerListPullReqPathParams

export const ReviewerListPullReq = ({ repo_ref, pullreq_number, ...props }: ReviewerListPullReqProps) => (
  <Get<TypesPullReqReviewer[], UsererrorError, void, ReviewerListPullReqPathParams>
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/reviewers`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseReviewerListPullReqProps = Omit<
  UseGetProps<TypesPullReqReviewer[], UsererrorError, void, ReviewerListPullReqPathParams>,
  'path'
> &
  ReviewerListPullReqPathParams

export const useReviewerListPullReq = ({ repo_ref, pullreq_number, ...props }: UseReviewerListPullReqProps) =>
  useGet<TypesPullReqReviewer[], UsererrorError, void, ReviewerListPullReqPathParams>(
    (paramsInPath: ReviewerListPullReqPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/reviewers`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface ReviewerAddPullReqPathParams {
  repo_ref: string
  pullreq_number: number
}

export type ReviewerAddPullReqProps = Omit<
  MutateProps<
    TypesPullReqReviewer,
    UsererrorError,
    void,
    OpenapiReviewerAddPullReqRequest,
    ReviewerAddPullReqPathParams
  >,
  'path' | 'verb'
> &
  ReviewerAddPullReqPathParams

export const ReviewerAddPullReq = ({ repo_ref, pullreq_number, ...props }: ReviewerAddPullReqProps) => (
  <Mutate<TypesPullReqReviewer, UsererrorError, void, OpenapiReviewerAddPullReqRequest, ReviewerAddPullReqPathParams>
    verb="PUT"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/reviewers`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseReviewerAddPullReqProps = Omit<
  UseMutateProps<
    TypesPullReqReviewer,
    UsererrorError,
    void,
    OpenapiReviewerAddPullReqRequest,
    ReviewerAddPullReqPathParams
  >,
  'path' | 'verb'
> &
  ReviewerAddPullReqPathParams

export const useReviewerAddPullReq = ({ repo_ref, pullreq_number, ...props }: UseReviewerAddPullReqProps) =>
  useMutate<TypesPullReqReviewer, UsererrorError, void, OpenapiReviewerAddPullReqRequest, ReviewerAddPullReqPathParams>(
    'PUT',
    (paramsInPath: ReviewerAddPullReqPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/reviewers`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface ReviewerDeletePullReqPathParams {
  repo_ref: string
  pullreq_number: number
}

export type ReviewerDeletePullReqProps = Omit<
  MutateProps<void, UsererrorError, void, number, ReviewerDeletePullReqPathParams>,
  'path' | 'verb'
> &
  ReviewerDeletePullReqPathParams

export const ReviewerDeletePullReq = ({ repo_ref, pullreq_number, ...props }: ReviewerDeletePullReqProps) => (
  <Mutate<void, UsererrorError, void, number, ReviewerDeletePullReqPathParams>
    verb="DELETE"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/reviewers`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseReviewerDeletePullReqProps = Omit<
  UseMutateProps<void, UsererrorError, void, number, ReviewerDeletePullReqPathParams>,
  'path' | 'verb'
> &
  ReviewerDeletePullReqPathParams

export const useReviewerDeletePullReq = ({ repo_ref, pullreq_number, ...props }: UseReviewerDeletePullReqProps) =>
  useMutate<void, UsererrorError, void, number, ReviewerDeletePullReqPathParams>(
    'DELETE',
    (paramsInPath: ReviewerDeletePullReqPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/reviewers`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface ReviewSubmitPullReqPathParams {
  repo_ref: string
  pullreq_number: number
}

export type ReviewSubmitPullReqProps = Omit<
  MutateProps<void, UsererrorError, void, OpenapiReviewSubmitPullReqRequest, ReviewSubmitPullReqPathParams>,
  'path' | 'verb'
> &
  ReviewSubmitPullReqPathParams

export const ReviewSubmitPullReq = ({ repo_ref, pullreq_number, ...props }: ReviewSubmitPullReqProps) => (
  <Mutate<void, UsererrorError, void, OpenapiReviewSubmitPullReqRequest, ReviewSubmitPullReqPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/reviews`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseReviewSubmitPullReqProps = Omit<
  UseMutateProps<void, UsererrorError, void, OpenapiReviewSubmitPullReqRequest, ReviewSubmitPullReqPathParams>,
  'path' | 'verb'
> &
  ReviewSubmitPullReqPathParams

export const useReviewSubmitPullReq = ({ repo_ref, pullreq_number, ...props }: UseReviewSubmitPullReqProps) =>
  useMutate<void, UsererrorError, void, OpenapiReviewSubmitPullReqRequest, ReviewSubmitPullReqPathParams>(
    'POST',
    (paramsInPath: ReviewSubmitPullReqPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/reviews`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface StatePullReqPathParams {
  repo_ref: string
  pullreq_number: number
}

export type StatePullReqProps = Omit<
  MutateProps<TypesPullReq, UsererrorError, void, OpenapiStatePullReqRequest, StatePullReqPathParams>,
  'path' | 'verb'
> &
  StatePullReqPathParams

export const StatePullReq = ({ repo_ref, pullreq_number, ...props }: StatePullReqProps) => (
  <Mutate<TypesPullReq, UsererrorError, void, OpenapiStatePullReqRequest, StatePullReqPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/pullreq/${pullreq_number}/state`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseStatePullReqProps = Omit<
  UseMutateProps<TypesPullReq, UsererrorError, void, OpenapiStatePullReqRequest, StatePullReqPathParams>,
  'path' | 'verb'
> &
  StatePullReqPathParams

export const useStatePullReq = ({ repo_ref, pullreq_number, ...props }: UseStatePullReqProps) =>
  useMutate<TypesPullReq, UsererrorError, void, OpenapiStatePullReqRequest, StatePullReqPathParams>(
    'POST',
    (paramsInPath: StatePullReqPathParams) =>
      `/repos/${paramsInPath.repo_ref}/pullreq/${paramsInPath.pullreq_number}/state`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, pullreq_number }, ...props }
  )

export interface GetRawQueryParams {
  /**
   * The git reference (branch / tag / commitID) that will be used to retrieve the data. If no value is provided the default branch of the repository is used.
   */
  git_ref?: string
}

export interface GetRawPathParams {
  repo_ref: string
  path: string
}

export type GetRawProps = Omit<GetProps<void, UsererrorError, GetRawQueryParams, GetRawPathParams>, 'path'> &
  GetRawPathParams

export const GetRaw = ({ repo_ref, path, ...props }: GetRawProps) => (
  <Get<void, UsererrorError, GetRawQueryParams, GetRawPathParams>
    path={`/repos/${repo_ref}/raw/${path}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetRawProps = Omit<UseGetProps<void, UsererrorError, GetRawQueryParams, GetRawPathParams>, 'path'> &
  GetRawPathParams

export const useGetRaw = ({ repo_ref, path, ...props }: UseGetRawProps) =>
  useGet<void, UsererrorError, GetRawQueryParams, GetRawPathParams>(
    (paramsInPath: GetRawPathParams) => `/repos/${paramsInPath.repo_ref}/raw/${paramsInPath.path}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, path }, ...props }
  )

export interface ListRepositoryServiceAccountsPathParams {
  repo_ref: string
}

export type ListRepositoryServiceAccountsProps = Omit<
  GetProps<TypesServiceAccount[], UsererrorError, void, ListRepositoryServiceAccountsPathParams>,
  'path'
> &
  ListRepositoryServiceAccountsPathParams

export const ListRepositoryServiceAccounts = ({ repo_ref, ...props }: ListRepositoryServiceAccountsProps) => (
  <Get<TypesServiceAccount[], UsererrorError, void, ListRepositoryServiceAccountsPathParams>
    path={`/repos/${repo_ref}/service-accounts`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListRepositoryServiceAccountsProps = Omit<
  UseGetProps<TypesServiceAccount[], UsererrorError, void, ListRepositoryServiceAccountsPathParams>,
  'path'
> &
  ListRepositoryServiceAccountsPathParams

export const useListRepositoryServiceAccounts = ({ repo_ref, ...props }: UseListRepositoryServiceAccountsProps) =>
  useGet<TypesServiceAccount[], UsererrorError, void, ListRepositoryServiceAccountsPathParams>(
    (paramsInPath: ListRepositoryServiceAccountsPathParams) => `/repos/${paramsInPath.repo_ref}/service-accounts`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface ListTagsQueryParams {
  /**
   * Indicates whether optional commit information should be included in the response.
   */
  include_commit?: boolean
  /**
   * The substring by which the tags are filtered.
   */
  query?: string
  /**
   * The order of the output.
   */
  order?: 'asc' | 'desc'
  /**
   * The data by which the tags are sorted.
   */
  sort?: 'name' | 'date'
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListTagsPathParams {
  repo_ref: string
}

export type ListTagsProps = Omit<
  GetProps<RepoCommitTag[], UsererrorError, ListTagsQueryParams, ListTagsPathParams>,
  'path'
> &
  ListTagsPathParams

export const ListTags = ({ repo_ref, ...props }: ListTagsProps) => (
  <Get<RepoCommitTag[], UsererrorError, ListTagsQueryParams, ListTagsPathParams>
    path={`/repos/${repo_ref}/tags`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListTagsProps = Omit<
  UseGetProps<RepoCommitTag[], UsererrorError, ListTagsQueryParams, ListTagsPathParams>,
  'path'
> &
  ListTagsPathParams

export const useListTags = ({ repo_ref, ...props }: UseListTagsProps) =>
  useGet<RepoCommitTag[], UsererrorError, ListTagsQueryParams, ListTagsPathParams>(
    (paramsInPath: ListTagsPathParams) => `/repos/${paramsInPath.repo_ref}/tags`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface CreateTagPathParams {
  repo_ref: string
}

export type CreateTagProps = Omit<
  MutateProps<RepoCommitTag, UsererrorError, void, OpenapiCreateTagRequest, CreateTagPathParams>,
  'path' | 'verb'
> &
  CreateTagPathParams

export const CreateTag = ({ repo_ref, ...props }: CreateTagProps) => (
  <Mutate<RepoCommitTag, UsererrorError, void, OpenapiCreateTagRequest, CreateTagPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/tags`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateTagProps = Omit<
  UseMutateProps<RepoCommitTag, UsererrorError, void, OpenapiCreateTagRequest, CreateTagPathParams>,
  'path' | 'verb'
> &
  CreateTagPathParams

export const useCreateTag = ({ repo_ref, ...props }: UseCreateTagProps) =>
  useMutate<RepoCommitTag, UsererrorError, void, OpenapiCreateTagRequest, CreateTagPathParams>(
    'POST',
    (paramsInPath: CreateTagPathParams) => `/repos/${paramsInPath.repo_ref}/tags`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface DeleteTagPathParams {
  repo_ref: string
}

export type DeleteTagProps = Omit<
  MutateProps<void, UsererrorError, void, string, DeleteTagPathParams>,
  'path' | 'verb'
> &
  DeleteTagPathParams

export const DeleteTag = ({ repo_ref, ...props }: DeleteTagProps) => (
  <Mutate<void, UsererrorError, void, string, DeleteTagPathParams>
    verb="DELETE"
    path={`/repos/${repo_ref}/tags`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteTagProps = Omit<
  UseMutateProps<void, UsererrorError, void, string, DeleteTagPathParams>,
  'path' | 'verb'
> &
  DeleteTagPathParams

export const useDeleteTag = ({ repo_ref, ...props }: UseDeleteTagProps) =>
  useMutate<void, UsererrorError, void, string, DeleteTagPathParams>(
    'DELETE',
    (paramsInPath: DeleteTagPathParams) => `/repos/${paramsInPath.repo_ref}/tags`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface ListWebhooksQueryParams {
  /**
   * The substring which is used to filter the spaces by their path name.
   */
  query?: string
  /**
   * The data by which the webhooks are sorted.
   */
  sort?: 'id' | 'display_name' | 'created' | 'updated'
  /**
   * The order of the output.
   */
  order?: 'asc' | 'desc'
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListWebhooksPathParams {
  repo_ref: string
}

export type ListWebhooksProps = Omit<
  GetProps<OpenapiWebhookType[], UsererrorError, ListWebhooksQueryParams, ListWebhooksPathParams>,
  'path'
> &
  ListWebhooksPathParams

export const ListWebhooks = ({ repo_ref, ...props }: ListWebhooksProps) => (
  <Get<OpenapiWebhookType[], UsererrorError, ListWebhooksQueryParams, ListWebhooksPathParams>
    path={`/repos/${repo_ref}/webhooks`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListWebhooksProps = Omit<
  UseGetProps<OpenapiWebhookType[], UsererrorError, ListWebhooksQueryParams, ListWebhooksPathParams>,
  'path'
> &
  ListWebhooksPathParams

export const useListWebhooks = ({ repo_ref, ...props }: UseListWebhooksProps) =>
  useGet<OpenapiWebhookType[], UsererrorError, ListWebhooksQueryParams, ListWebhooksPathParams>(
    (paramsInPath: ListWebhooksPathParams) => `/repos/${paramsInPath.repo_ref}/webhooks`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface CreateWebhookPathParams {
  repo_ref: string
}

export type CreateWebhookProps = Omit<
  MutateProps<OpenapiWebhookType, UsererrorError, void, OpenapiCreateWebhookRequest, CreateWebhookPathParams>,
  'path' | 'verb'
> &
  CreateWebhookPathParams

export const CreateWebhook = ({ repo_ref, ...props }: CreateWebhookProps) => (
  <Mutate<OpenapiWebhookType, UsererrorError, void, OpenapiCreateWebhookRequest, CreateWebhookPathParams>
    verb="POST"
    path={`/repos/${repo_ref}/webhooks`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateWebhookProps = Omit<
  UseMutateProps<OpenapiWebhookType, UsererrorError, void, OpenapiCreateWebhookRequest, CreateWebhookPathParams>,
  'path' | 'verb'
> &
  CreateWebhookPathParams

export const useCreateWebhook = ({ repo_ref, ...props }: UseCreateWebhookProps) =>
  useMutate<OpenapiWebhookType, UsererrorError, void, OpenapiCreateWebhookRequest, CreateWebhookPathParams>(
    'POST',
    (paramsInPath: CreateWebhookPathParams) => `/repos/${paramsInPath.repo_ref}/webhooks`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface DeleteWebhookPathParams {
  repo_ref: string
}

export type DeleteWebhookProps = Omit<
  MutateProps<void, UsererrorError, void, number, DeleteWebhookPathParams>,
  'path' | 'verb'
> &
  DeleteWebhookPathParams

export const DeleteWebhook = ({ repo_ref, ...props }: DeleteWebhookProps) => (
  <Mutate<void, UsererrorError, void, number, DeleteWebhookPathParams>
    verb="DELETE"
    path={`/repos/${repo_ref}/webhooks`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteWebhookProps = Omit<
  UseMutateProps<void, UsererrorError, void, number, DeleteWebhookPathParams>,
  'path' | 'verb'
> &
  DeleteWebhookPathParams

export const useDeleteWebhook = ({ repo_ref, ...props }: UseDeleteWebhookProps) =>
  useMutate<void, UsererrorError, void, number, DeleteWebhookPathParams>(
    'DELETE',
    (paramsInPath: DeleteWebhookPathParams) => `/repos/${paramsInPath.repo_ref}/webhooks`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref }, ...props }
  )

export interface GetWebhookPathParams {
  repo_ref: string
  webhook_id: number
}

export type GetWebhookProps = Omit<GetProps<OpenapiWebhookType, UsererrorError, void, GetWebhookPathParams>, 'path'> &
  GetWebhookPathParams

export const GetWebhook = ({ repo_ref, webhook_id, ...props }: GetWebhookProps) => (
  <Get<OpenapiWebhookType, UsererrorError, void, GetWebhookPathParams>
    path={`/repos/${repo_ref}/webhooks/${webhook_id}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetWebhookProps = Omit<
  UseGetProps<OpenapiWebhookType, UsererrorError, void, GetWebhookPathParams>,
  'path'
> &
  GetWebhookPathParams

export const useGetWebhook = ({ repo_ref, webhook_id, ...props }: UseGetWebhookProps) =>
  useGet<OpenapiWebhookType, UsererrorError, void, GetWebhookPathParams>(
    (paramsInPath: GetWebhookPathParams) => `/repos/${paramsInPath.repo_ref}/webhooks/${paramsInPath.webhook_id}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, webhook_id }, ...props }
  )

export interface UpdateWebhookPathParams {
  repo_ref: string
  webhook_id: number
}

export type UpdateWebhookProps = Omit<
  MutateProps<OpenapiWebhookType, UsererrorError, void, OpenapiUpdateWebhookRequest, UpdateWebhookPathParams>,
  'path' | 'verb'
> &
  UpdateWebhookPathParams

export const UpdateWebhook = ({ repo_ref, webhook_id, ...props }: UpdateWebhookProps) => (
  <Mutate<OpenapiWebhookType, UsererrorError, void, OpenapiUpdateWebhookRequest, UpdateWebhookPathParams>
    verb="PATCH"
    path={`/repos/${repo_ref}/webhooks/${webhook_id}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateWebhookProps = Omit<
  UseMutateProps<OpenapiWebhookType, UsererrorError, void, OpenapiUpdateWebhookRequest, UpdateWebhookPathParams>,
  'path' | 'verb'
> &
  UpdateWebhookPathParams

export const useUpdateWebhook = ({ repo_ref, webhook_id, ...props }: UseUpdateWebhookProps) =>
  useMutate<OpenapiWebhookType, UsererrorError, void, OpenapiUpdateWebhookRequest, UpdateWebhookPathParams>(
    'PATCH',
    (paramsInPath: UpdateWebhookPathParams) => `/repos/${paramsInPath.repo_ref}/webhooks/${paramsInPath.webhook_id}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, webhook_id }, ...props }
  )

export interface ListWebhookExecutionsQueryParams {
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListWebhookExecutionsPathParams {
  repo_ref: string
  webhook_id: number
}

export type ListWebhookExecutionsProps = Omit<
  GetProps<TypesWebhookExecution[], UsererrorError, ListWebhookExecutionsQueryParams, ListWebhookExecutionsPathParams>,
  'path'
> &
  ListWebhookExecutionsPathParams

export const ListWebhookExecutions = ({ repo_ref, webhook_id, ...props }: ListWebhookExecutionsProps) => (
  <Get<TypesWebhookExecution[], UsererrorError, ListWebhookExecutionsQueryParams, ListWebhookExecutionsPathParams>
    path={`/repos/${repo_ref}/webhooks/${webhook_id}/executions`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListWebhookExecutionsProps = Omit<
  UseGetProps<
    TypesWebhookExecution[],
    UsererrorError,
    ListWebhookExecutionsQueryParams,
    ListWebhookExecutionsPathParams
  >,
  'path'
> &
  ListWebhookExecutionsPathParams

export const useListWebhookExecutions = ({ repo_ref, webhook_id, ...props }: UseListWebhookExecutionsProps) =>
  useGet<TypesWebhookExecution[], UsererrorError, ListWebhookExecutionsQueryParams, ListWebhookExecutionsPathParams>(
    (paramsInPath: ListWebhookExecutionsPathParams) =>
      `/repos/${paramsInPath.repo_ref}/webhooks/${paramsInPath.webhook_id}/executions`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, webhook_id }, ...props }
  )

export interface GetWebhookExecutionQueryParams {
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface GetWebhookExecutionPathParams {
  repo_ref: string
  webhook_id: number
  webhook_execution_id: number
}

export type GetWebhookExecutionProps = Omit<
  GetProps<TypesWebhookExecution, UsererrorError, GetWebhookExecutionQueryParams, GetWebhookExecutionPathParams>,
  'path'
> &
  GetWebhookExecutionPathParams

export const GetWebhookExecution = ({
  repo_ref,
  webhook_id,
  webhook_execution_id,
  ...props
}: GetWebhookExecutionProps) => (
  <Get<TypesWebhookExecution, UsererrorError, GetWebhookExecutionQueryParams, GetWebhookExecutionPathParams>
    path={`/repos/${repo_ref}/webhooks/${webhook_id}/executions/${webhook_execution_id}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetWebhookExecutionProps = Omit<
  UseGetProps<TypesWebhookExecution, UsererrorError, GetWebhookExecutionQueryParams, GetWebhookExecutionPathParams>,
  'path'
> &
  GetWebhookExecutionPathParams

export const useGetWebhookExecution = ({
  repo_ref,
  webhook_id,
  webhook_execution_id,
  ...props
}: UseGetWebhookExecutionProps) =>
  useGet<TypesWebhookExecution, UsererrorError, GetWebhookExecutionQueryParams, GetWebhookExecutionPathParams>(
    (paramsInPath: GetWebhookExecutionPathParams) =>
      `/repos/${paramsInPath.repo_ref}/webhooks/${paramsInPath.webhook_id}/executions/${paramsInPath.webhook_execution_id}`,
    { base: getConfig('code/api/v1'), pathParams: { repo_ref, webhook_id, webhook_execution_id }, ...props }
  )

export type ListGitignoreProps = Omit<GetProps<string[], UsererrorError, void, void>, 'path'>

export const ListGitignore = (props: ListGitignoreProps) => (
  <Get<string[], UsererrorError, void, void> path={`/resources/gitignore`} base={getConfig('code/api/v1')} {...props} />
)

export type UseListGitignoreProps = Omit<UseGetProps<string[], UsererrorError, void, void>, 'path'>

export const useListGitignore = (props: UseListGitignoreProps) =>
  useGet<string[], UsererrorError, void, void>(`/resources/gitignore`, { base: getConfig('code/api/v1'), ...props })

export interface ListLicensesResponse {
  label?: string
  value?: string
}
;[]

export type ListLicensesProps = Omit<GetProps<ListLicensesResponse, UsererrorError, void, void>, 'path'>

export const ListLicenses = (props: ListLicensesProps) => (
  <Get<ListLicensesResponse, UsererrorError, void, void>
    path={`/resources/license`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListLicensesProps = Omit<UseGetProps<ListLicensesResponse, UsererrorError, void, void>, 'path'>

export const useListLicenses = (props: UseListLicensesProps) =>
  useGet<ListLicensesResponse, UsererrorError, void, void>(`/resources/license`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type CreateSecretProps = Omit<
  MutateProps<TypesSecret, UsererrorError, void, OpenapiCreateSecretRequest, void>,
  'path' | 'verb'
>

export const CreateSecret = (props: CreateSecretProps) => (
  <Mutate<TypesSecret, UsererrorError, void, OpenapiCreateSecretRequest, void>
    verb="POST"
    path={`/secrets`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateSecretProps = Omit<
  UseMutateProps<TypesSecret, UsererrorError, void, OpenapiCreateSecretRequest, void>,
  'path' | 'verb'
>

export const useCreateSecret = (props: UseCreateSecretProps) =>
  useMutate<TypesSecret, UsererrorError, void, OpenapiCreateSecretRequest, void>('POST', `/secrets`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type DeleteSecretProps = Omit<MutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const DeleteSecret = (props: DeleteSecretProps) => (
  <Mutate<void, UsererrorError, void, string, void>
    verb="DELETE"
    path={`/secrets`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteSecretProps = Omit<UseMutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const useDeleteSecret = (props: UseDeleteSecretProps) =>
  useMutate<void, UsererrorError, void, string, void>('DELETE', `/secrets`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export interface FindSecretPathParams {
  secret_ref: string
}

export type FindSecretProps = Omit<GetProps<TypesSecret, UsererrorError, void, FindSecretPathParams>, 'path'> &
  FindSecretPathParams

export const FindSecret = ({ secret_ref, ...props }: FindSecretProps) => (
  <Get<TypesSecret, UsererrorError, void, FindSecretPathParams>
    path={`/secrets/${secret_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseFindSecretProps = Omit<UseGetProps<TypesSecret, UsererrorError, void, FindSecretPathParams>, 'path'> &
  FindSecretPathParams

export const useFindSecret = ({ secret_ref, ...props }: UseFindSecretProps) =>
  useGet<TypesSecret, UsererrorError, void, FindSecretPathParams>(
    (paramsInPath: FindSecretPathParams) => `/secrets/${paramsInPath.secret_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { secret_ref }, ...props }
  )

export interface UpdateSecretPathParams {
  secret_ref: string
}

export type UpdateSecretProps = Omit<
  MutateProps<TypesSecret, UsererrorError, void, OpenapiUpdateSecretRequest, UpdateSecretPathParams>,
  'path' | 'verb'
> &
  UpdateSecretPathParams

export const UpdateSecret = ({ secret_ref, ...props }: UpdateSecretProps) => (
  <Mutate<TypesSecret, UsererrorError, void, OpenapiUpdateSecretRequest, UpdateSecretPathParams>
    verb="PATCH"
    path={`/secrets/${secret_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateSecretProps = Omit<
  UseMutateProps<TypesSecret, UsererrorError, void, OpenapiUpdateSecretRequest, UpdateSecretPathParams>,
  'path' | 'verb'
> &
  UpdateSecretPathParams

export const useUpdateSecret = ({ secret_ref, ...props }: UseUpdateSecretProps) =>
  useMutate<TypesSecret, UsererrorError, void, OpenapiUpdateSecretRequest, UpdateSecretPathParams>(
    'PATCH',
    (paramsInPath: UpdateSecretPathParams) => `/secrets/${paramsInPath.secret_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { secret_ref }, ...props }
  )

export type CreateSpaceProps = Omit<
  MutateProps<TypesSpace, UsererrorError, void, OpenapiCreateSpaceRequest, void>,
  'path' | 'verb'
>

export const CreateSpace = (props: CreateSpaceProps) => (
  <Mutate<TypesSpace, UsererrorError, void, OpenapiCreateSpaceRequest, void>
    verb="POST"
    path={`/spaces`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateSpaceProps = Omit<
  UseMutateProps<TypesSpace, UsererrorError, void, OpenapiCreateSpaceRequest, void>,
  'path' | 'verb'
>

export const useCreateSpace = (props: UseCreateSpaceProps) =>
  useMutate<TypesSpace, UsererrorError, void, OpenapiCreateSpaceRequest, void>('POST', `/spaces`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type DeleteSpaceProps = Omit<MutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const DeleteSpace = (props: DeleteSpaceProps) => (
  <Mutate<void, UsererrorError, void, string, void>
    verb="DELETE"
    path={`/spaces`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteSpaceProps = Omit<UseMutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const useDeleteSpace = (props: UseDeleteSpaceProps) =>
  useMutate<void, UsererrorError, void, string, void>('DELETE', `/spaces`, { base: getConfig('code/api/v1'), ...props })

export interface GetSpacePathParams {
  space_ref: string
}

export type GetSpaceProps = Omit<GetProps<TypesSpace, UsererrorError, void, GetSpacePathParams>, 'path'> &
  GetSpacePathParams

export const GetSpace = ({ space_ref, ...props }: GetSpaceProps) => (
  <Get<TypesSpace, UsererrorError, void, GetSpacePathParams>
    path={`/spaces/${space_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetSpaceProps = Omit<UseGetProps<TypesSpace, UsererrorError, void, GetSpacePathParams>, 'path'> &
  GetSpacePathParams

export const useGetSpace = ({ space_ref, ...props }: UseGetSpaceProps) =>
  useGet<TypesSpace, UsererrorError, void, GetSpacePathParams>(
    (paramsInPath: GetSpacePathParams) => `/spaces/${paramsInPath.space_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface UpdateSpacePathParams {
  space_ref: string
}

export type UpdateSpaceProps = Omit<
  MutateProps<TypesSpace, UsererrorError, void, OpenapiUpdateSpaceRequest, UpdateSpacePathParams>,
  'path' | 'verb'
> &
  UpdateSpacePathParams

export const UpdateSpace = ({ space_ref, ...props }: UpdateSpaceProps) => (
  <Mutate<TypesSpace, UsererrorError, void, OpenapiUpdateSpaceRequest, UpdateSpacePathParams>
    verb="PATCH"
    path={`/spaces/${space_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateSpaceProps = Omit<
  UseMutateProps<TypesSpace, UsererrorError, void, OpenapiUpdateSpaceRequest, UpdateSpacePathParams>,
  'path' | 'verb'
> &
  UpdateSpacePathParams

export const useUpdateSpace = ({ space_ref, ...props }: UseUpdateSpaceProps) =>
  useMutate<TypesSpace, UsererrorError, void, OpenapiUpdateSpaceRequest, UpdateSpacePathParams>(
    'PATCH',
    (paramsInPath: UpdateSpacePathParams) => `/spaces/${paramsInPath.space_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface ListConnectorsQueryParams {
  /**
   * The substring which is used to filter the repositories by their path name.
   */
  query?: string
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListConnectorsPathParams {
  space_ref: string
}

export type ListConnectorsProps = Omit<
  GetProps<TypesConnector[], UsererrorError, ListConnectorsQueryParams, ListConnectorsPathParams>,
  'path'
> &
  ListConnectorsPathParams

export const ListConnectors = ({ space_ref, ...props }: ListConnectorsProps) => (
  <Get<TypesConnector[], UsererrorError, ListConnectorsQueryParams, ListConnectorsPathParams>
    path={`/spaces/${space_ref}/connectors`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListConnectorsProps = Omit<
  UseGetProps<TypesConnector[], UsererrorError, ListConnectorsQueryParams, ListConnectorsPathParams>,
  'path'
> &
  ListConnectorsPathParams

export const useListConnectors = ({ space_ref, ...props }: UseListConnectorsProps) =>
  useGet<TypesConnector[], UsererrorError, ListConnectorsQueryParams, ListConnectorsPathParams>(
    (paramsInPath: ListConnectorsPathParams) => `/spaces/${paramsInPath.space_ref}/connectors`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface MembershipListQueryParams {
  /**
   * The substring by which the space members are filtered.
   */
  query?: string
  /**
   * The order of the output.
   */
  order?: 'asc' | 'desc'
  /**
   * The field by which the space members are sorted.
   */
  sort?: 'created' | 'name'
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface MembershipListPathParams {
  space_ref: string
}

export type MembershipListProps = Omit<
  GetProps<TypesMembershipUser[], UsererrorError, MembershipListQueryParams, MembershipListPathParams>,
  'path'
> &
  MembershipListPathParams

export const MembershipList = ({ space_ref, ...props }: MembershipListProps) => (
  <Get<TypesMembershipUser[], UsererrorError, MembershipListQueryParams, MembershipListPathParams>
    path={`/spaces/${space_ref}/members`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseMembershipListProps = Omit<
  UseGetProps<TypesMembershipUser[], UsererrorError, MembershipListQueryParams, MembershipListPathParams>,
  'path'
> &
  MembershipListPathParams

export const useMembershipList = ({ space_ref, ...props }: UseMembershipListProps) =>
  useGet<TypesMembershipUser[], UsererrorError, MembershipListQueryParams, MembershipListPathParams>(
    (paramsInPath: MembershipListPathParams) => `/spaces/${paramsInPath.space_ref}/members`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface MembershipAddPathParams {
  space_ref: string
}

export interface MembershipAddRequestBody {
  role?: EnumMembershipRole
  user_uid?: string
}

export type MembershipAddProps = Omit<
  MutateProps<TypesMembershipUser, UsererrorError, void, MembershipAddRequestBody, MembershipAddPathParams>,
  'path' | 'verb'
> &
  MembershipAddPathParams

export const MembershipAdd = ({ space_ref, ...props }: MembershipAddProps) => (
  <Mutate<TypesMembershipUser, UsererrorError, void, MembershipAddRequestBody, MembershipAddPathParams>
    verb="POST"
    path={`/spaces/${space_ref}/members`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseMembershipAddProps = Omit<
  UseMutateProps<TypesMembershipUser, UsererrorError, void, MembershipAddRequestBody, MembershipAddPathParams>,
  'path' | 'verb'
> &
  MembershipAddPathParams

export const useMembershipAdd = ({ space_ref, ...props }: UseMembershipAddProps) =>
  useMutate<TypesMembershipUser, UsererrorError, void, MembershipAddRequestBody, MembershipAddPathParams>(
    'POST',
    (paramsInPath: MembershipAddPathParams) => `/spaces/${paramsInPath.space_ref}/members`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface MembershipDeletePathParams {
  space_ref: string
}

export type MembershipDeleteProps = Omit<
  MutateProps<void, UsererrorError, void, string, MembershipDeletePathParams>,
  'path' | 'verb'
> &
  MembershipDeletePathParams

export const MembershipDelete = ({ space_ref, ...props }: MembershipDeleteProps) => (
  <Mutate<void, UsererrorError, void, string, MembershipDeletePathParams>
    verb="DELETE"
    path={`/spaces/${space_ref}/members`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseMembershipDeleteProps = Omit<
  UseMutateProps<void, UsererrorError, void, string, MembershipDeletePathParams>,
  'path' | 'verb'
> &
  MembershipDeletePathParams

export const useMembershipDelete = ({ space_ref, ...props }: UseMembershipDeleteProps) =>
  useMutate<void, UsererrorError, void, string, MembershipDeletePathParams>(
    'DELETE',
    (paramsInPath: MembershipDeletePathParams) => `/spaces/${paramsInPath.space_ref}/members`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface MembershipUpdatePathParams {
  space_ref: string
  user_uid: string
}

export interface MembershipUpdateRequestBody {
  role?: EnumMembershipRole
}

export type MembershipUpdateProps = Omit<
  MutateProps<TypesMembershipUser, UsererrorError, void, MembershipUpdateRequestBody, MembershipUpdatePathParams>,
  'path' | 'verb'
> &
  MembershipUpdatePathParams

export const MembershipUpdate = ({ space_ref, user_uid, ...props }: MembershipUpdateProps) => (
  <Mutate<TypesMembershipUser, UsererrorError, void, MembershipUpdateRequestBody, MembershipUpdatePathParams>
    verb="PATCH"
    path={`/spaces/${space_ref}/members/${user_uid}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseMembershipUpdateProps = Omit<
  UseMutateProps<TypesMembershipUser, UsererrorError, void, MembershipUpdateRequestBody, MembershipUpdatePathParams>,
  'path' | 'verb'
> &
  MembershipUpdatePathParams

export const useMembershipUpdate = ({ space_ref, user_uid, ...props }: UseMembershipUpdateProps) =>
  useMutate<TypesMembershipUser, UsererrorError, void, MembershipUpdateRequestBody, MembershipUpdatePathParams>(
    'PATCH',
    (paramsInPath: MembershipUpdatePathParams) => `/spaces/${paramsInPath.space_ref}/members/${paramsInPath.user_uid}`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref, user_uid }, ...props }
  )

export interface MoveSpacePathParams {
  space_ref: string
}

export type MoveSpaceProps = Omit<
  MutateProps<TypesSpace, UsererrorError, void, OpenapiMoveSpaceRequest, MoveSpacePathParams>,
  'path' | 'verb'
> &
  MoveSpacePathParams

export const MoveSpace = ({ space_ref, ...props }: MoveSpaceProps) => (
  <Mutate<TypesSpace, UsererrorError, void, OpenapiMoveSpaceRequest, MoveSpacePathParams>
    verb="POST"
    path={`/spaces/${space_ref}/move`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseMoveSpaceProps = Omit<
  UseMutateProps<TypesSpace, UsererrorError, void, OpenapiMoveSpaceRequest, MoveSpacePathParams>,
  'path' | 'verb'
> &
  MoveSpacePathParams

export const useMoveSpace = ({ space_ref, ...props }: UseMoveSpaceProps) =>
  useMutate<TypesSpace, UsererrorError, void, OpenapiMoveSpaceRequest, MoveSpacePathParams>(
    'POST',
    (paramsInPath: MoveSpacePathParams) => `/spaces/${paramsInPath.space_ref}/move`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface ListPathsQueryParams {
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListPathsPathParams {
  space_ref: string
}

export type ListPathsProps = Omit<
  GetProps<TypesPath[], UsererrorError, ListPathsQueryParams, ListPathsPathParams>,
  'path'
> &
  ListPathsPathParams

export const ListPaths = ({ space_ref, ...props }: ListPathsProps) => (
  <Get<TypesPath[], UsererrorError, ListPathsQueryParams, ListPathsPathParams>
    path={`/spaces/${space_ref}/paths`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListPathsProps = Omit<
  UseGetProps<TypesPath[], UsererrorError, ListPathsQueryParams, ListPathsPathParams>,
  'path'
> &
  ListPathsPathParams

export const useListPaths = ({ space_ref, ...props }: UseListPathsProps) =>
  useGet<TypesPath[], UsererrorError, ListPathsQueryParams, ListPathsPathParams>(
    (paramsInPath: ListPathsPathParams) => `/spaces/${paramsInPath.space_ref}/paths`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface CreatePathPathParams {
  space_ref: string
}

export type CreatePathProps = Omit<
  MutateProps<TypesPath, UsererrorError, void, OpenapiCreatePathRequest, CreatePathPathParams>,
  'path' | 'verb'
> &
  CreatePathPathParams

export const CreatePath = ({ space_ref, ...props }: CreatePathProps) => (
  <Mutate<TypesPath, UsererrorError, void, OpenapiCreatePathRequest, CreatePathPathParams>
    verb="POST"
    path={`/spaces/${space_ref}/paths`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreatePathProps = Omit<
  UseMutateProps<TypesPath, UsererrorError, void, OpenapiCreatePathRequest, CreatePathPathParams>,
  'path' | 'verb'
> &
  CreatePathPathParams

export const useCreatePath = ({ space_ref, ...props }: UseCreatePathProps) =>
  useMutate<TypesPath, UsererrorError, void, OpenapiCreatePathRequest, CreatePathPathParams>(
    'POST',
    (paramsInPath: CreatePathPathParams) => `/spaces/${paramsInPath.space_ref}/paths`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface DeletePathPathParams {
  space_ref: string
}

export type DeletePathProps = Omit<
  MutateProps<void, UsererrorError, void, string, DeletePathPathParams>,
  'path' | 'verb'
> &
  DeletePathPathParams

export const DeletePath = ({ space_ref, ...props }: DeletePathProps) => (
  <Mutate<void, UsererrorError, void, string, DeletePathPathParams>
    verb="DELETE"
    path={`/spaces/${space_ref}/paths`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeletePathProps = Omit<
  UseMutateProps<void, UsererrorError, void, string, DeletePathPathParams>,
  'path' | 'verb'
> &
  DeletePathPathParams

export const useDeletePath = ({ space_ref, ...props }: UseDeletePathProps) =>
  useMutate<void, UsererrorError, void, string, DeletePathPathParams>(
    'DELETE',
    (paramsInPath: DeletePathPathParams) => `/spaces/${paramsInPath.space_ref}/paths`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface ListReposQueryParams {
  /**
   * The substring which is used to filter the repositories by their path name.
   */
  query?: string
  /**
   * The data by which the repositories are sorted.
   */
  sort?: 'uid' | 'path' | 'created' | 'updated'
  /**
   * The order of the output.
   */
  order?: 'asc' | 'desc'
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListReposPathParams {
  space_ref: string
}

export type ListReposProps = Omit<
  GetProps<TypesRepository[], UsererrorError, ListReposQueryParams, ListReposPathParams>,
  'path'
> &
  ListReposPathParams

export const ListRepos = ({ space_ref, ...props }: ListReposProps) => (
  <Get<TypesRepository[], UsererrorError, ListReposQueryParams, ListReposPathParams>
    path={`/spaces/${space_ref}/repos`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListReposProps = Omit<
  UseGetProps<TypesRepository[], UsererrorError, ListReposQueryParams, ListReposPathParams>,
  'path'
> &
  ListReposPathParams

export const useListRepos = ({ space_ref, ...props }: UseListReposProps) =>
  useGet<TypesRepository[], UsererrorError, ListReposQueryParams, ListReposPathParams>(
    (paramsInPath: ListReposPathParams) => `/spaces/${paramsInPath.space_ref}/repos`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface ListSecretsQueryParams {
  /**
   * The substring which is used to filter the repositories by their path name.
   */
  query?: string
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListSecretsPathParams {
  space_ref: string
}

export type ListSecretsProps = Omit<
  GetProps<TypesSecret[], UsererrorError, ListSecretsQueryParams, ListSecretsPathParams>,
  'path'
> &
  ListSecretsPathParams

export const ListSecrets = ({ space_ref, ...props }: ListSecretsProps) => (
  <Get<TypesSecret[], UsererrorError, ListSecretsQueryParams, ListSecretsPathParams>
    path={`/spaces/${space_ref}/secrets`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListSecretsProps = Omit<
  UseGetProps<TypesSecret[], UsererrorError, ListSecretsQueryParams, ListSecretsPathParams>,
  'path'
> &
  ListSecretsPathParams

export const useListSecrets = ({ space_ref, ...props }: UseListSecretsProps) =>
  useGet<TypesSecret[], UsererrorError, ListSecretsQueryParams, ListSecretsPathParams>(
    (paramsInPath: ListSecretsPathParams) => `/spaces/${paramsInPath.space_ref}/secrets`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface ListServiceAccountsPathParams {
  space_ref: string
}

export type ListServiceAccountsProps = Omit<
  GetProps<TypesServiceAccount[], UsererrorError, void, ListServiceAccountsPathParams>,
  'path'
> &
  ListServiceAccountsPathParams

export const ListServiceAccounts = ({ space_ref, ...props }: ListServiceAccountsProps) => (
  <Get<TypesServiceAccount[], UsererrorError, void, ListServiceAccountsPathParams>
    path={`/spaces/${space_ref}/service-accounts`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListServiceAccountsProps = Omit<
  UseGetProps<TypesServiceAccount[], UsererrorError, void, ListServiceAccountsPathParams>,
  'path'
> &
  ListServiceAccountsPathParams

export const useListServiceAccounts = ({ space_ref, ...props }: UseListServiceAccountsProps) =>
  useGet<TypesServiceAccount[], UsererrorError, void, ListServiceAccountsPathParams>(
    (paramsInPath: ListServiceAccountsPathParams) => `/spaces/${paramsInPath.space_ref}/service-accounts`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface ListSpacesQueryParams {
  /**
   * The substring which is used to filter the spaces by their path name.
   */
  query?: string
  /**
   * The data by which the spaces are sorted.
   */
  sort?: 'uid' | 'path' | 'created' | 'updated'
  /**
   * The order of the output.
   */
  order?: 'asc' | 'desc'
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListSpacesPathParams {
  space_ref: string
}

export type ListSpacesProps = Omit<
  GetProps<TypesSpace[], UsererrorError, ListSpacesQueryParams, ListSpacesPathParams>,
  'path'
> &
  ListSpacesPathParams

export const ListSpaces = ({ space_ref, ...props }: ListSpacesProps) => (
  <Get<TypesSpace[], UsererrorError, ListSpacesQueryParams, ListSpacesPathParams>
    path={`/spaces/${space_ref}/spaces`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListSpacesProps = Omit<
  UseGetProps<TypesSpace[], UsererrorError, ListSpacesQueryParams, ListSpacesPathParams>,
  'path'
> &
  ListSpacesPathParams

export const useListSpaces = ({ space_ref, ...props }: UseListSpacesProps) =>
  useGet<TypesSpace[], UsererrorError, ListSpacesQueryParams, ListSpacesPathParams>(
    (paramsInPath: ListSpacesPathParams) => `/spaces/${paramsInPath.space_ref}/spaces`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export interface ListTemplatesQueryParams {
  /**
   * The substring which is used to filter the repositories by their path name.
   */
  query?: string
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export interface ListTemplatesPathParams {
  space_ref: string
}

export type ListTemplatesProps = Omit<
  GetProps<TypesTemplate[], UsererrorError, ListTemplatesQueryParams, ListTemplatesPathParams>,
  'path'
> &
  ListTemplatesPathParams

export const ListTemplates = ({ space_ref, ...props }: ListTemplatesProps) => (
  <Get<TypesTemplate[], UsererrorError, ListTemplatesQueryParams, ListTemplatesPathParams>
    path={`/spaces/${space_ref}/templates`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseListTemplatesProps = Omit<
  UseGetProps<TypesTemplate[], UsererrorError, ListTemplatesQueryParams, ListTemplatesPathParams>,
  'path'
> &
  ListTemplatesPathParams

export const useListTemplates = ({ space_ref, ...props }: UseListTemplatesProps) =>
  useGet<TypesTemplate[], UsererrorError, ListTemplatesQueryParams, ListTemplatesPathParams>(
    (paramsInPath: ListTemplatesPathParams) => `/spaces/${paramsInPath.space_ref}/templates`,
    { base: getConfig('code/api/v1'), pathParams: { space_ref }, ...props }
  )

export type GetSystemConfigProps = Omit<GetProps<SystemConfigOutput, UsererrorError, void, void>, 'path'>

export const GetSystemConfig = (props: GetSystemConfigProps) => (
  <Get<SystemConfigOutput, UsererrorError, void, void>
    path={`/system/config`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseGetSystemConfigProps = Omit<UseGetProps<SystemConfigOutput, UsererrorError, void, void>, 'path'>

export const useGetSystemConfig = (props: UseGetSystemConfigProps) =>
  useGet<SystemConfigOutput, UsererrorError, void, void>(`/system/config`, { base: getConfig('code/api/v1'), ...props })

export type CreateTemplateProps = Omit<
  MutateProps<TypesTemplate, UsererrorError, void, OpenapiCreateTemplateRequest, void>,
  'path' | 'verb'
>

export const CreateTemplate = (props: CreateTemplateProps) => (
  <Mutate<TypesTemplate, UsererrorError, void, OpenapiCreateTemplateRequest, void>
    verb="POST"
    path={`/templates`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateTemplateProps = Omit<
  UseMutateProps<TypesTemplate, UsererrorError, void, OpenapiCreateTemplateRequest, void>,
  'path' | 'verb'
>

export const useCreateTemplate = (props: UseCreateTemplateProps) =>
  useMutate<TypesTemplate, UsererrorError, void, OpenapiCreateTemplateRequest, void>('POST', `/templates`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type DeleteTemplateProps = Omit<MutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const DeleteTemplate = (props: DeleteTemplateProps) => (
  <Mutate<void, UsererrorError, void, string, void>
    verb="DELETE"
    path={`/templates`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseDeleteTemplateProps = Omit<UseMutateProps<void, UsererrorError, void, string, void>, 'path' | 'verb'>

export const useDeleteTemplate = (props: UseDeleteTemplateProps) =>
  useMutate<void, UsererrorError, void, string, void>('DELETE', `/templates`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export interface FindTemplatePathParams {
  template_ref: string
}

export type FindTemplateProps = Omit<GetProps<TypesTemplate, UsererrorError, void, FindTemplatePathParams>, 'path'> &
  FindTemplatePathParams

export const FindTemplate = ({ template_ref, ...props }: FindTemplateProps) => (
  <Get<TypesTemplate, UsererrorError, void, FindTemplatePathParams>
    path={`/templates/${template_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseFindTemplateProps = Omit<
  UseGetProps<TypesTemplate, UsererrorError, void, FindTemplatePathParams>,
  'path'
> &
  FindTemplatePathParams

export const useFindTemplate = ({ template_ref, ...props }: UseFindTemplateProps) =>
  useGet<TypesTemplate, UsererrorError, void, FindTemplatePathParams>(
    (paramsInPath: FindTemplatePathParams) => `/templates/${paramsInPath.template_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { template_ref }, ...props }
  )

export interface UpdateTemplatePathParams {
  template_ref: string
}

export type UpdateTemplateProps = Omit<
  MutateProps<TypesTemplate, UsererrorError, void, OpenapiUpdateTemplateRequest, UpdateTemplatePathParams>,
  'path' | 'verb'
> &
  UpdateTemplatePathParams

export const UpdateTemplate = ({ template_ref, ...props }: UpdateTemplateProps) => (
  <Mutate<TypesTemplate, UsererrorError, void, OpenapiUpdateTemplateRequest, UpdateTemplatePathParams>
    verb="PATCH"
    path={`/templates/${template_ref}`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateTemplateProps = Omit<
  UseMutateProps<TypesTemplate, UsererrorError, void, OpenapiUpdateTemplateRequest, UpdateTemplatePathParams>,
  'path' | 'verb'
> &
  UpdateTemplatePathParams

export const useUpdateTemplate = ({ template_ref, ...props }: UseUpdateTemplateProps) =>
  useMutate<TypesTemplate, UsererrorError, void, OpenapiUpdateTemplateRequest, UpdateTemplatePathParams>(
    'PATCH',
    (paramsInPath: UpdateTemplatePathParams) => `/templates/${paramsInPath.template_ref}`,
    { base: getConfig('code/api/v1'), pathParams: { template_ref }, ...props }
  )

export type GetUserProps = Omit<GetProps<TypesUser, UsererrorError, void, void>, 'path'>

export const GetUser = (props: GetUserProps) => (
  <Get<TypesUser, UsererrorError, void, void> path={`/user`} base={getConfig('code/api/v1')} {...props} />
)

export type UseGetUserProps = Omit<UseGetProps<TypesUser, UsererrorError, void, void>, 'path'>

export const useGetUser = (props: UseGetUserProps) =>
  useGet<TypesUser, UsererrorError, void, void>(`/user`, { base: getConfig('code/api/v1'), ...props })

export type UpdateUserProps = Omit<MutateProps<TypesUser, UsererrorError, void, UserUpdateInput, void>, 'path' | 'verb'>

export const UpdateUser = (props: UpdateUserProps) => (
  <Mutate<TypesUser, UsererrorError, void, UserUpdateInput, void>
    verb="PATCH"
    path={`/user`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseUpdateUserProps = Omit<
  UseMutateProps<TypesUser, UsererrorError, void, UserUpdateInput, void>,
  'path' | 'verb'
>

export const useUpdateUser = (props: UseUpdateUserProps) =>
  useMutate<TypesUser, UsererrorError, void, UserUpdateInput, void>('PATCH', `/user`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export interface MembershipSpacesQueryParams {
  /**
   * The substring by which the spaces the users is a member of are filtered.
   */
  query?: string
  /**
   * The order of the output.
   */
  order?: 'asc' | 'desc'
  /**
   * The field by which the spaces the user is a member of are sorted.
   */
  sort?: 'created' | 'path' | 'uid'
  /**
   * The page to return.
   */
  page?: number
  /**
   * The maximum number of results to return.
   */
  limit?: number
}

export type MembershipSpacesProps = Omit<
  GetProps<TypesMembershipSpace[], UsererrorError, MembershipSpacesQueryParams, void>,
  'path'
>

export const MembershipSpaces = (props: MembershipSpacesProps) => (
  <Get<TypesMembershipSpace[], UsererrorError, MembershipSpacesQueryParams, void>
    path={`/user/memberships`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseMembershipSpacesProps = Omit<
  UseGetProps<TypesMembershipSpace[], UsererrorError, MembershipSpacesQueryParams, void>,
  'path'
>

export const useMembershipSpaces = (props: UseMembershipSpacesProps) =>
  useGet<TypesMembershipSpace[], UsererrorError, MembershipSpacesQueryParams, void>(`/user/memberships`, {
    base: getConfig('code/api/v1'),
    ...props
  })

export type CreateTokenProps = Omit<
  MutateProps<TypesTokenResponse, UsererrorError, void, OpenapiCreateTokenRequest, void>,
  'path' | 'verb'
>

export const CreateToken = (props: CreateTokenProps) => (
  <Mutate<TypesTokenResponse, UsererrorError, void, OpenapiCreateTokenRequest, void>
    verb="POST"
    path={`/user/token`}
    base={getConfig('code/api/v1')}
    {...props}
  />
)

export type UseCreateTokenProps = Omit<
  UseMutateProps<TypesTokenResponse, UsererrorError, void, OpenapiCreateTokenRequest, void>,
  'path' | 'verb'
>

export const useCreateToken = (props: UseCreateTokenProps) =>
  useMutate<TypesTokenResponse, UsererrorError, void, OpenapiCreateTokenRequest, void>('POST', `/user/token`, {
    base: getConfig('code/api/v1'),
    ...props
  })