pub fn actions_add_custom_labels_to_self_hosted_runner_for_org_request(
  base: Request(a),
  org: String,
  runner_id: Int,
  data: b,
) -> Request(b)

pub fn actions_add_custom_labels_to_self_hosted_runner_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_add_custom_labels_to_self_hosted_runner_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  runner_id: Int,
  data: b,
) -> Request(b)

pub fn actions_add_custom_labels_to_self_hosted_runner_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_add_repo_access_to_self_hosted_runner_group_in_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
  repository_id: Int,
) -> Request(a)

pub fn actions_add_repo_access_to_self_hosted_runner_group_in_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_add_selected_repo_to_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  repository_id: Int,
) -> Request(a)

pub fn actions_add_selected_repo_to_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_add_selected_repo_to_org_variable_request(
  base: Request(a),
  org: String,
  name: String,
  repository_id: Int,
) -> Request(a)

pub fn actions_add_selected_repo_to_org_variable_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_add_self_hosted_runner_to_group_for_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
  runner_id: Int,
) -> Request(a)

pub fn actions_add_self_hosted_runner_to_group_for_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_approve_workflow_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_approve_workflow_run_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_cancel_workflow_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_cancel_workflow_run_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_create_environment_variable_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
  data: b,
) -> Request(b)

pub fn actions_create_environment_variable_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_create_or_update_environment_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn actions_create_or_update_environment_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_create_or_update_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn actions_create_or_update_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_create_or_update_repo_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn actions_create_or_update_repo_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_create_org_variable_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn actions_create_org_variable_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_create_registration_token_for_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn actions_create_registration_token_for_org_response(
  response: Response(BitArray),
) -> Result(Result(AuthenticationToken, String), DecodeError)

pub fn actions_create_registration_token_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_create_registration_token_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(AuthenticationToken, String), DecodeError)

pub fn actions_create_remove_token_for_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn actions_create_remove_token_for_org_response(
  response: Response(BitArray),
) -> Result(Result(AuthenticationToken, String), DecodeError)

pub fn actions_create_remove_token_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_create_remove_token_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(AuthenticationToken, String), DecodeError)

pub fn actions_create_repo_variable_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn actions_create_repo_variable_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_create_self_hosted_runner_group_for_org_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn actions_create_self_hosted_runner_group_for_org_response(
  response: Response(BitArray),
) -> Result(Result(RunnerGroupsOrg, String), DecodeError)

pub fn actions_create_workflow_dispatch_request(
  base: Request(a),
  owner: String,
  repo: String,
  workflow_id: String,
  data: b,
) -> Request(b)

pub fn actions_create_workflow_dispatch_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_actions_cache_by_id_request(
  base: Request(a),
  owner: String,
  repo: String,
  cache_id: Int,
) -> Request(a)

pub fn actions_delete_actions_cache_by_id_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_actions_cache_by_key_request(
  base: Request(a),
  owner: String,
  repo: String,
  key key: String,
  ref ref: Option(String),
) -> Request(a)

pub fn actions_delete_actions_cache_by_key_response(
  response: Response(BitArray),
) -> Result(Result(ActionsCacheList, String), DecodeError)

pub fn actions_delete_artifact_request(
  base: Request(a),
  owner: String,
  repo: String,
  artifact_id: Int,
) -> Request(a)

pub fn actions_delete_artifact_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_environment_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
  secret_name: String,
) -> Request(a)

pub fn actions_delete_environment_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_environment_variable_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
  name: String,
) -> Request(a)

pub fn actions_delete_environment_variable_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
) -> Request(a)

pub fn actions_delete_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_org_variable_request(
  base: Request(a),
  org: String,
  name: String,
) -> Request(a)

pub fn actions_delete_org_variable_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_repo_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  secret_name: String,
) -> Request(a)

pub fn actions_delete_repo_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_repo_variable_request(
  base: Request(a),
  owner: String,
  repo: String,
  name: String,
) -> Request(a)

pub fn actions_delete_repo_variable_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_self_hosted_runner_from_org_request(
  base: Request(a),
  org: String,
  runner_id: Int,
) -> Request(a)

pub fn actions_delete_self_hosted_runner_from_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_self_hosted_runner_from_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  runner_id: Int,
) -> Request(a)

pub fn actions_delete_self_hosted_runner_from_repo_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_self_hosted_runner_group_from_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
) -> Request(a)

pub fn actions_delete_self_hosted_runner_group_from_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_workflow_run_logs_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_delete_workflow_run_logs_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_delete_workflow_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_delete_workflow_run_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_disable_selected_repository_github_actions_organization_request(
  base: Request(a),
  org: String,
  repository_id: Int,
) -> Request(a)

pub fn actions_disable_selected_repository_github_actions_organization_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_disable_workflow_request(
  base: Request(a),
  owner: String,
  repo: String,
  workflow_id: String,
) -> Request(a)

pub fn actions_disable_workflow_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_download_artifact_request(
  base: Request(a),
  owner: String,
  repo: String,
  artifact_id: Int,
  archive_format: String,
) -> Request(a)

pub fn actions_download_artifact_response(
  response: Response(a),
) -> Result(Result(b, String), c)

pub fn actions_download_job_logs_for_workflow_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  job_id: Int,
) -> Request(a)

pub fn actions_download_job_logs_for_workflow_run_response(
  response: Response(a),
) -> Result(Result(b, String), c)

pub fn actions_download_workflow_run_attempt_logs_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
  attempt_number: Int,
) -> Request(a)

pub fn actions_download_workflow_run_attempt_logs_response(
  response: Response(a),
) -> Result(Result(b, String), c)

pub fn actions_download_workflow_run_logs_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_download_workflow_run_logs_response(
  response: Response(a),
) -> Result(Result(b, String), c)

pub fn actions_enable_selected_repository_github_actions_organization_request(
  base: Request(a),
  org: String,
  repository_id: Int,
) -> Request(a)

pub fn actions_enable_selected_repository_github_actions_organization_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_enable_workflow_request(
  base: Request(a),
  owner: String,
  repo: String,
  workflow_id: String,
) -> Request(a)

pub fn actions_enable_workflow_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_force_cancel_workflow_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_force_cancel_workflow_run_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_generate_runner_jitconfig_for_org_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn actions_generate_runner_jitconfig_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_generate_runner_jitconfig_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn actions_generate_runner_jitconfig_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_get_actions_cache_list_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
  ref ref: Option(String),
  key key: Option(String),
  sort sort: Option(String),
  direction direction: Option(String),
) -> Request(a)

pub fn actions_get_actions_cache_list_response(
  response: Response(BitArray),
) -> Result(Result(ActionsCacheList, String), DecodeError)

pub fn actions_get_actions_cache_usage_by_repo_for_org_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_get_actions_cache_usage_by_repo_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_get_actions_cache_usage_for_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn actions_get_actions_cache_usage_for_org_response(
  response: Response(BitArray),
) -> Result(
  Result(ActionsCacheUsageOrgEnterprise, String),
  DecodeError,
)

pub fn actions_get_actions_cache_usage_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_get_actions_cache_usage_response(
  response: Response(BitArray),
) -> Result(
  Result(ActionsCacheUsageByRepository, String),
  DecodeError,
)

pub fn actions_get_allowed_actions_organization_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn actions_get_allowed_actions_organization_response(
  response: Response(BitArray),
) -> Result(Result(SelectedActions, String), DecodeError)

pub fn actions_get_allowed_actions_repository_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_get_allowed_actions_repository_response(
  response: Response(BitArray),
) -> Result(Result(SelectedActions, String), DecodeError)

pub fn actions_get_artifact_request(
  base: Request(a),
  owner: String,
  repo: String,
  artifact_id: Int,
) -> Request(a)

pub fn actions_get_artifact_response(
  response: Response(BitArray),
) -> Result(Result(Artifact, String), DecodeError)

pub fn actions_get_custom_oidc_sub_claim_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_get_custom_oidc_sub_claim_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(OidcCustomSubRepo, String), DecodeError)

pub fn actions_get_environment_public_key_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
) -> Request(a)

pub fn actions_get_environment_public_key_response(
  response: Response(BitArray),
) -> Result(Result(ActionsPublicKey, String), DecodeError)

pub fn actions_get_environment_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
  secret_name: String,
) -> Request(a)

pub fn actions_get_environment_secret_response(
  response: Response(BitArray),
) -> Result(Result(ActionsSecret, String), DecodeError)

pub fn actions_get_environment_variable_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
  name: String,
) -> Request(a)

pub fn actions_get_environment_variable_response(
  response: Response(BitArray),
) -> Result(Result(ActionsVariable, String), DecodeError)

pub fn actions_get_github_actions_default_workflow_permissions_organization_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn actions_get_github_actions_default_workflow_permissions_organization_response(
  response: Response(BitArray),
) -> Result(
  Result(ActionsGetDefaultWorkflowPermissions, String),
  DecodeError,
)

pub fn actions_get_github_actions_default_workflow_permissions_repository_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_get_github_actions_default_workflow_permissions_repository_response(
  response: Response(BitArray),
) -> Result(
  Result(ActionsGetDefaultWorkflowPermissions, String),
  DecodeError,
)

pub fn actions_get_github_actions_permissions_organization_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn actions_get_github_actions_permissions_organization_response(
  response: Response(BitArray),
) -> Result(
  Result(ActionsOrganizationPermissions, String),
  DecodeError,
)

pub fn actions_get_github_actions_permissions_repository_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_get_github_actions_permissions_repository_response(
  response: Response(BitArray),
) -> Result(
  Result(ActionsRepositoryPermissions, String),
  DecodeError,
)

pub fn actions_get_job_for_workflow_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  job_id: Int,
) -> Request(a)

pub fn actions_get_job_for_workflow_run_response(
  response: Response(BitArray),
) -> Result(Result(Job, String), DecodeError)

pub fn actions_get_org_public_key_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn actions_get_org_public_key_response(
  response: Response(BitArray),
) -> Result(Result(ActionsPublicKey, String), DecodeError)

pub fn actions_get_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
) -> Request(a)

pub fn actions_get_org_secret_response(
  response: Response(BitArray),
) -> Result(
  Result(OrganizationActionsSecret, String),
  DecodeError,
)

pub fn actions_get_org_variable_request(
  base: Request(a),
  org: String,
  name: String,
) -> Request(a)

pub fn actions_get_org_variable_response(
  response: Response(BitArray),
) -> Result(
  Result(OrganizationActionsVariable, String),
  DecodeError,
)

pub fn actions_get_pending_deployments_for_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_get_pending_deployments_for_run_response(
  response: Response(BitArray),
) -> Result(Result(List(PendingDeployment), String), DecodeError)

pub fn actions_get_repo_public_key_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_get_repo_public_key_response(
  response: Response(BitArray),
) -> Result(Result(ActionsPublicKey, String), DecodeError)

pub fn actions_get_repo_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  secret_name: String,
) -> Request(a)

pub fn actions_get_repo_secret_response(
  response: Response(BitArray),
) -> Result(Result(ActionsSecret, String), DecodeError)

pub fn actions_get_repo_variable_request(
  base: Request(a),
  owner: String,
  repo: String,
  name: String,
) -> Request(a)

pub fn actions_get_repo_variable_response(
  response: Response(BitArray),
) -> Result(Result(ActionsVariable, String), DecodeError)

pub fn actions_get_reviews_for_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_get_reviews_for_run_response(
  response: Response(BitArray),
) -> Result(
  Result(List(EnvironmentApprovals), String),
  DecodeError,
)

pub fn actions_get_self_hosted_runner_for_org_request(
  base: Request(a),
  org: String,
  runner_id: Int,
) -> Request(a)

pub fn actions_get_self_hosted_runner_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Runner, String), DecodeError)

pub fn actions_get_self_hosted_runner_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  runner_id: Int,
) -> Request(a)

pub fn actions_get_self_hosted_runner_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Runner, String), DecodeError)

pub fn actions_get_self_hosted_runner_group_for_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
) -> Request(a)

pub fn actions_get_self_hosted_runner_group_for_org_response(
  response: Response(BitArray),
) -> Result(Result(RunnerGroupsOrg, String), DecodeError)

pub fn actions_get_workflow_access_to_repository_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_get_workflow_access_to_repository_response(
  response: Response(BitArray),
) -> Result(
  Result(ActionsWorkflowAccessToRepository, String),
  DecodeError,
)

pub fn actions_get_workflow_request(
  base: Request(a),
  owner: String,
  repo: String,
  workflow_id: String,
) -> Request(a)

pub fn actions_get_workflow_response(
  response: Response(BitArray),
) -> Result(Result(Workflow, String), DecodeError)

pub fn actions_get_workflow_run_attempt_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
  attempt_number: Int,
  exclude_pull_requests exclude_pull_requests: Option(Bool),
) -> Request(a)

pub fn actions_get_workflow_run_attempt_response(
  response: Response(BitArray),
) -> Result(Result(WorkflowRun, String), DecodeError)

pub fn actions_get_workflow_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
  exclude_pull_requests exclude_pull_requests: Option(Bool),
) -> Request(a)

pub fn actions_get_workflow_run_response(
  response: Response(BitArray),
) -> Result(Result(WorkflowRun, String), DecodeError)

pub fn actions_get_workflow_run_usage_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_get_workflow_run_usage_response(
  response: Response(BitArray),
) -> Result(Result(WorkflowRunUsage, String), DecodeError)

pub fn actions_get_workflow_usage_request(
  base: Request(a),
  owner: String,
  repo: String,
  workflow_id: String,
) -> Request(a)

pub fn actions_get_workflow_usage_response(
  response: Response(BitArray),
) -> Result(Result(WorkflowUsage, String), DecodeError)

pub fn actions_list_artifacts_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
  name name: Option(String),
) -> Request(a)

pub fn actions_list_artifacts_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_environment_secrets_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_environment_secrets_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_environment_variables_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_environment_variables_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_jobs_for_workflow_run_attempt_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
  attempt_number: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_jobs_for_workflow_run_attempt_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_jobs_for_workflow_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
  filter filter: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_jobs_for_workflow_run_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_labels_for_self_hosted_runner_for_org_request(
  base: Request(a),
  org: String,
  runner_id: Int,
) -> Request(a)

pub fn actions_list_labels_for_self_hosted_runner_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_labels_for_self_hosted_runner_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  runner_id: Int,
) -> Request(a)

pub fn actions_list_labels_for_self_hosted_runner_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_org_secrets_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_org_secrets_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_org_variables_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_org_variables_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_repo_access_to_self_hosted_runner_group_in_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn actions_list_repo_access_to_self_hosted_runner_group_in_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_repo_organization_secrets_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_repo_organization_secrets_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_repo_organization_variables_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_repo_organization_variables_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_repo_secrets_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_repo_secrets_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_repo_variables_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_repo_variables_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_repo_workflows_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_repo_workflows_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_runner_applications_for_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn actions_list_runner_applications_for_org_response(
  response: Response(BitArray),
) -> Result(Result(List(RunnerApplication), String), DecodeError)

pub fn actions_list_runner_applications_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn actions_list_runner_applications_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(List(RunnerApplication), String), DecodeError)

pub fn actions_list_selected_repos_for_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn actions_list_selected_repos_for_org_secret_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_selected_repos_for_org_variable_request(
  base: Request(a),
  org: String,
  name: String,
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn actions_list_selected_repos_for_org_variable_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_selected_repositories_enabled_github_actions_organization_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_selected_repositories_enabled_github_actions_organization_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_self_hosted_runner_groups_for_org_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
  visible_to_repository visible_to_repository: Option(String),
) -> Request(a)

pub fn actions_list_self_hosted_runner_groups_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_self_hosted_runners_for_org_request(
  base: Request(a),
  org: String,
  name name: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_self_hosted_runners_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_self_hosted_runners_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  name name: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_self_hosted_runners_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_self_hosted_runners_in_group_for_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn actions_list_self_hosted_runners_in_group_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_workflow_run_artifacts_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
  name name: Option(String),
) -> Request(a)

pub fn actions_list_workflow_run_artifacts_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_workflow_runs_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  actor actor: Option(String),
  branch branch: Option(String),
  event event: Option(String),
  status status: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
  created created: Option(String),
  exclude_pull_requests exclude_pull_requests: Option(Bool),
  check_suite_id check_suite_id: Option(Int),
  head_sha head_sha: Option(String),
) -> Request(a)

pub fn actions_list_workflow_runs_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_list_workflow_runs_request(
  base: Request(a),
  owner: String,
  repo: String,
  workflow_id: String,
  actor actor: Option(String),
  branch branch: Option(String),
  event event: Option(String),
  status status: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
  created created: Option(String),
  exclude_pull_requests exclude_pull_requests: Option(Bool),
  check_suite_id check_suite_id: Option(Int),
  head_sha head_sha: Option(String),
) -> Request(a)

pub fn actions_list_workflow_runs_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_re_run_job_for_workflow_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  job_id: Int,
  data: b,
) -> Request(b)

pub fn actions_re_run_job_for_workflow_run_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_re_run_workflow_failed_jobs_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
  data: b,
) -> Request(b)

pub fn actions_re_run_workflow_failed_jobs_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_re_run_workflow_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
  data: b,
) -> Request(b)

pub fn actions_re_run_workflow_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_remove_all_custom_labels_from_self_hosted_runner_for_org_request(
  base: Request(a),
  org: String,
  runner_id: Int,
) -> Request(a)

pub fn actions_remove_all_custom_labels_from_self_hosted_runner_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_remove_all_custom_labels_from_self_hosted_runner_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  runner_id: Int,
) -> Request(a)

pub fn actions_remove_all_custom_labels_from_self_hosted_runner_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_remove_custom_label_from_self_hosted_runner_for_org_request(
  base: Request(a),
  org: String,
  runner_id: Int,
  name: String,
) -> Request(a)

pub fn actions_remove_custom_label_from_self_hosted_runner_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_remove_custom_label_from_self_hosted_runner_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  runner_id: Int,
  name: String,
) -> Request(a)

pub fn actions_remove_custom_label_from_self_hosted_runner_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_remove_repo_access_to_self_hosted_runner_group_in_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
  repository_id: Int,
) -> Request(a)

pub fn actions_remove_repo_access_to_self_hosted_runner_group_in_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_remove_selected_repo_from_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  repository_id: Int,
) -> Request(a)

pub fn actions_remove_selected_repo_from_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_remove_selected_repo_from_org_variable_request(
  base: Request(a),
  org: String,
  name: String,
  repository_id: Int,
) -> Request(a)

pub fn actions_remove_selected_repo_from_org_variable_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_remove_self_hosted_runner_from_group_for_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
  runner_id: Int,
) -> Request(a)

pub fn actions_remove_self_hosted_runner_from_group_for_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_review_custom_gates_for_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
) -> Request(a)

pub fn actions_review_custom_gates_for_run_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_review_pending_deployments_for_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  run_id: Int,
  data: b,
) -> Request(b)

pub fn actions_review_pending_deployments_for_run_response(
  response: Response(BitArray),
) -> Result(Result(List(Deployment), String), DecodeError)

pub fn actions_set_allowed_actions_organization_request(
  base: Request(a),
  org: String,
  selected_actions: SelectedActions,
) -> Request(BitArray)

pub fn actions_set_allowed_actions_organization_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_allowed_actions_repository_request(
  base: Request(a),
  owner: String,
  repo: String,
  selected_actions: SelectedActions,
) -> Request(BitArray)

pub fn actions_set_allowed_actions_repository_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_custom_labels_for_self_hosted_runner_for_org_request(
  base: Request(a),
  org: String,
  runner_id: Int,
  data: b,
) -> Request(b)

pub fn actions_set_custom_labels_for_self_hosted_runner_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_set_custom_labels_for_self_hosted_runner_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  runner_id: Int,
  data: b,
) -> Request(b)

pub fn actions_set_custom_labels_for_self_hosted_runner_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn actions_set_custom_oidc_sub_claim_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn actions_set_custom_oidc_sub_claim_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn actions_set_github_actions_default_workflow_permissions_organization_request(
  base: Request(a),
  org: String,
  actions_set_default_workflow_permissions: ActionsSetDefaultWorkflowPermissions,
) -> Request(BitArray)

pub fn actions_set_github_actions_default_workflow_permissions_organization_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_github_actions_default_workflow_permissions_repository_request(
  base: Request(a),
  owner: String,
  repo: String,
  actions_set_default_workflow_permissions: ActionsSetDefaultWorkflowPermissions,
) -> Request(BitArray)

pub fn actions_set_github_actions_default_workflow_permissions_repository_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_github_actions_permissions_organization_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn actions_set_github_actions_permissions_organization_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_github_actions_permissions_repository_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn actions_set_github_actions_permissions_repository_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_repo_access_to_self_hosted_runner_group_in_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
  data: b,
) -> Request(b)

pub fn actions_set_repo_access_to_self_hosted_runner_group_in_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_selected_repos_for_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn actions_set_selected_repos_for_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_selected_repos_for_org_variable_request(
  base: Request(a),
  org: String,
  name: String,
  data: b,
) -> Request(b)

pub fn actions_set_selected_repos_for_org_variable_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_selected_repositories_enabled_github_actions_organization_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn actions_set_selected_repositories_enabled_github_actions_organization_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_self_hosted_runners_in_group_for_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
  data: b,
) -> Request(b)

pub fn actions_set_self_hosted_runners_in_group_for_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_set_workflow_access_to_repository_request(
  base: Request(a),
  owner: String,
  repo: String,
  actions_workflow_access_to_repository: ActionsWorkflowAccessToRepository,
) -> Request(BitArray)

pub fn actions_set_workflow_access_to_repository_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_update_environment_variable_request(
  base: Request(a),
  owner: String,
  repo: String,
  environment_name: String,
  name: String,
  data: b,
) -> Request(b)

pub fn actions_update_environment_variable_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_update_org_variable_request(
  base: Request(a),
  org: String,
  name: String,
  data: b,
) -> Request(b)

pub fn actions_update_org_variable_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_update_repo_variable_request(
  base: Request(a),
  owner: String,
  repo: String,
  name: String,
  data: b,
) -> Request(b)

pub fn actions_update_repo_variable_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn actions_update_self_hosted_runner_group_for_org_request(
  base: Request(a),
  org: String,
  runner_group_id: Int,
  data: b,
) -> Request(b)

pub fn actions_update_self_hosted_runner_group_for_org_response(
  response: Response(BitArray),
) -> Result(Result(RunnerGroupsOrg, String), DecodeError)

pub fn activity_check_repo_is_starred_by_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn activity_check_repo_is_starred_by_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn activity_delete_repo_subscription_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn activity_delete_repo_subscription_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn activity_delete_thread_subscription_request(
  base: Request(a),
  thread_id: Int,
) -> Request(a)

pub fn activity_delete_thread_subscription_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn activity_get_feeds_request(base: Request(a)) -> Request(a)

pub fn activity_get_feeds_response(
  response: Response(BitArray),
) -> Result(Result(Feed, String), DecodeError)

pub fn activity_get_repo_subscription_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn activity_get_repo_subscription_response(
  response: Response(BitArray),
) -> Result(Result(RepositorySubscription, String), DecodeError)

pub fn activity_get_thread_request(
  base: Request(a),
  thread_id: Int,
) -> Request(a)

pub fn activity_get_thread_response(
  response: Response(BitArray),
) -> Result(Result(Thread, String), DecodeError)

pub fn activity_get_thread_subscription_for_authenticated_user_request(
  base: Request(a),
  thread_id: Int,
) -> Request(a)

pub fn activity_get_thread_subscription_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(ThreadSubscription, String), DecodeError)

pub fn activity_list_events_for_authenticated_user_request(
  base: Request(a),
  username: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_events_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Event), String), DecodeError)

pub fn activity_list_notifications_for_authenticated_user_request(
  base: Request(a),
  all all: Option(Bool),
  participating participating: Option(Bool),
  since since: Option(String),
  before before: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn activity_list_notifications_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Thread), String), DecodeError)

pub fn activity_list_org_events_for_authenticated_user_request(
  base: Request(a),
  username: String,
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_org_events_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Event), String), DecodeError)

pub fn activity_list_public_events_for_repo_network_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_public_events_for_repo_network_response(
  response: Response(BitArray),
) -> Result(Result(List(Event), String), DecodeError)

pub fn activity_list_public_events_for_user_request(
  base: Request(a),
  username: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_public_events_for_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Event), String), DecodeError)

pub fn activity_list_public_events_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_public_events_response(
  response: Response(BitArray),
) -> Result(Result(List(Event), String), DecodeError)

pub fn activity_list_public_org_events_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_public_org_events_response(
  response: Response(BitArray),
) -> Result(Result(List(Event), String), DecodeError)

pub fn activity_list_received_events_for_user_request(
  base: Request(a),
  username: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_received_events_for_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Event), String), DecodeError)

pub fn activity_list_received_public_events_for_user_request(
  base: Request(a),
  username: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_received_public_events_for_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Event), String), DecodeError)

pub fn activity_list_repo_events_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_repo_events_response(
  response: Response(BitArray),
) -> Result(Result(List(Event), String), DecodeError)

pub fn activity_list_repo_notifications_for_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
  all all: Option(Bool),
  participating participating: Option(Bool),
  since since: Option(String),
  before before: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_repo_notifications_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Thread), String), DecodeError)

pub fn activity_list_repos_starred_by_authenticated_user_request(
  base: Request(a),
  sort sort: Option(String),
  direction direction: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_repos_starred_by_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Repository), String), DecodeError)

pub fn activity_list_repos_starred_by_user_request(
  base: Request(a),
  username: String,
  sort sort: Option(String),
  direction direction: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_repos_starred_by_user_response(
  response: Response(BitArray),
) -> Result(Result(Nil, String), DecodeError)

pub fn activity_list_repos_watched_by_user_request(
  base: Request(a),
  username: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_repos_watched_by_user_response(
  response: Response(BitArray),
) -> Result(Result(List(MinimalRepository), String), DecodeError)

pub fn activity_list_stargazers_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_stargazers_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Nil, String), DecodeError)

pub fn activity_list_watched_repos_for_authenticated_user_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_watched_repos_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(List(MinimalRepository), String), DecodeError)

pub fn activity_list_watchers_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn activity_list_watchers_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(List(SimpleUser), String), DecodeError)

pub fn activity_mark_notifications_as_read_request(
  base: Request(a),
  data: b,
) -> Request(b)

pub fn activity_mark_notifications_as_read_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn activity_mark_repo_notifications_as_read_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn activity_mark_repo_notifications_as_read_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn activity_mark_thread_as_done_request(
  base: Request(a),
  thread_id: Int,
) -> Request(a)

pub fn activity_mark_thread_as_done_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn activity_mark_thread_as_read_request(
  base: Request(a),
  thread_id: Int,
) -> Request(a)

pub fn activity_mark_thread_as_read_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn activity_set_repo_subscription_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn activity_set_repo_subscription_response(
  response: Response(BitArray),
) -> Result(Result(RepositorySubscription, String), DecodeError)

pub fn activity_set_thread_subscription_request(
  base: Request(a),
  thread_id: Int,
  data: b,
) -> Request(b)

pub fn activity_set_thread_subscription_response(
  response: Response(BitArray),
) -> Result(Result(ThreadSubscription, String), DecodeError)

pub fn activity_star_repo_for_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn activity_star_repo_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn activity_unstar_repo_for_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn activity_unstar_repo_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn api_insights_get_route_stats_by_actor_request(
  base: Request(a),
  org: String,
  actor_type: String,
  actor_id: Int,
  min_timestamp min_timestamp: String,
  max_timestamp max_timestamp: String,
  page page: Option(Int),
  per_page per_page: Option(Int),
  direction direction: Option(String),
  sort sort: b,
) -> Request(a)

pub fn api_insights_get_route_stats_by_actor_response(
  response: Response(BitArray),
) -> Result(Result(a, String), DecodeError)

pub fn api_insights_get_subject_stats_request(
  base: Request(a),
  org: String,
  min_timestamp min_timestamp: String,
  max_timestamp max_timestamp: String,
  page page: Option(Int),
  per_page per_page: Option(Int),
  direction direction: Option(String),
  sort sort: b,
) -> Request(a)

pub fn api_insights_get_subject_stats_response(
  response: Response(BitArray),
) -> Result(Result(a, String), DecodeError)

pub fn api_insights_get_summary_stats_by_actor_request(
  base: Request(a),
  org: String,
  actor_type: String,
  actor_id: Int,
  min_timestamp min_timestamp: String,
  max_timestamp max_timestamp: String,
) -> Request(a)

pub fn api_insights_get_summary_stats_by_actor_response(
  response: Response(BitArray),
) -> Result(Result(ApiInsightsSummaryStats, String), DecodeError)

pub fn api_insights_get_summary_stats_by_user_request(
  base: Request(a),
  org: String,
  user_id: String,
  min_timestamp min_timestamp: String,
  max_timestamp max_timestamp: String,
) -> Request(a)

pub fn api_insights_get_summary_stats_by_user_response(
  response: Response(BitArray),
) -> Result(Result(ApiInsightsSummaryStats, String), DecodeError)

pub fn api_insights_get_summary_stats_request(
  base: Request(a),
  org: String,
  min_timestamp min_timestamp: String,
  max_timestamp max_timestamp: String,
) -> Request(a)

pub fn api_insights_get_summary_stats_response(
  response: Response(BitArray),
) -> Result(Result(ApiInsightsSummaryStats, String), DecodeError)

pub fn api_insights_get_time_stats_by_actor_request(
  base: Request(a),
  org: String,
  actor_type: String,
  actor_id: Int,
  min_timestamp min_timestamp: String,
  max_timestamp max_timestamp: String,
  timestamp_increment timestamp_increment: String,
) -> Request(a)

pub fn api_insights_get_time_stats_by_actor_response(
  response: Response(BitArray),
) -> Result(Result(a, String), DecodeError)

pub fn api_insights_get_time_stats_by_user_request(
  base: Request(a),
  org: String,
  user_id: String,
  min_timestamp min_timestamp: String,
  max_timestamp max_timestamp: String,
  timestamp_increment timestamp_increment: String,
) -> Request(a)

pub fn api_insights_get_time_stats_by_user_response(
  response: Response(BitArray),
) -> Result(Result(a, String), DecodeError)

pub fn api_insights_get_time_stats_request(
  base: Request(a),
  org: String,
  min_timestamp min_timestamp: String,
  max_timestamp max_timestamp: String,
  timestamp_increment timestamp_increment: String,
) -> Request(a)

pub fn api_insights_get_time_stats_response(
  response: Response(BitArray),
) -> Result(Result(a, String), DecodeError)

pub fn api_insights_get_user_stats_request(
  base: Request(a),
  org: String,
  user_id: String,
  min_timestamp min_timestamp: String,
  max_timestamp max_timestamp: String,
  page page: Option(Int),
  per_page per_page: Option(Int),
  direction direction: Option(String),
  sort sort: b,
) -> Request(a)

pub fn api_insights_get_user_stats_response(
  response: Response(BitArray),
) -> Result(Result(a, String), DecodeError)

pub fn apps_add_repo_to_installation_for_authenticated_user_request(
  base: Request(a),
  installation_id: Int,
  repository_id: Int,
) -> Request(a)

pub fn apps_add_repo_to_installation_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn apps_check_token_request(
  base: Request(a),
  client_id: String,
  data: b,
) -> Request(b)

pub fn apps_check_token_response(
  response: Response(BitArray),
) -> Result(Result(Authorization, String), DecodeError)

pub fn apps_create_from_manifest_request(
  base: Request(a),
  code: String,
) -> Request(a)

pub fn apps_create_from_manifest_response(
  response: Response(BitArray),
) -> Result(Result(Nil, String), DecodeError)

pub fn apps_create_installation_access_token_request(
  base: Request(a),
  installation_id: Int,
  data: b,
) -> Request(b)

pub fn apps_create_installation_access_token_response(
  response: Response(BitArray),
) -> Result(Result(InstallationToken, String), DecodeError)

pub fn apps_delete_authorization_request(
  base: Request(a),
  client_id: String,
  data: b,
) -> Request(b)

pub fn apps_delete_authorization_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn apps_delete_installation_request(
  base: Request(a),
  installation_id: Int,
) -> Request(a)

pub fn apps_delete_installation_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn apps_delete_token_request(
  base: Request(a),
  client_id: String,
  data: b,
) -> Request(b)

pub fn apps_delete_token_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn apps_get_authenticated_request(
  base: Request(a),
) -> Request(a)

pub fn apps_get_authenticated_response(
  response: Response(BitArray),
) -> Result(Result(Integration, String), DecodeError)

pub fn apps_get_by_slug_request(
  base: Request(a),
  app_slug: String,
) -> Request(a)

pub fn apps_get_by_slug_response(
  response: Response(BitArray),
) -> Result(Result(Integration, String), DecodeError)

pub fn apps_get_installation_request(
  base: Request(a),
  installation_id: Int,
) -> Request(a)

pub fn apps_get_installation_response(
  response: Response(BitArray),
) -> Result(Result(Installation, String), DecodeError)

pub fn apps_get_org_installation_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn apps_get_org_installation_response(
  response: Response(BitArray),
) -> Result(Result(Installation, String), DecodeError)

pub fn apps_get_repo_installation_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn apps_get_repo_installation_response(
  response: Response(BitArray),
) -> Result(Result(Installation, String), DecodeError)

pub fn apps_get_subscription_plan_for_account_request(
  base: Request(a),
  account_id: Int,
) -> Request(a)

pub fn apps_get_subscription_plan_for_account_response(
  response: Response(BitArray),
) -> Result(Result(MarketplacePurchase, String), DecodeError)

pub fn apps_get_subscription_plan_for_account_stubbed_request(
  base: Request(a),
  account_id: Int,
) -> Request(a)

pub fn apps_get_subscription_plan_for_account_stubbed_response(
  response: Response(BitArray),
) -> Result(Result(MarketplacePurchase, String), DecodeError)

pub fn apps_get_user_installation_request(
  base: Request(a),
  username: String,
) -> Request(a)

pub fn apps_get_user_installation_response(
  response: Response(BitArray),
) -> Result(Result(Installation, String), DecodeError)

pub fn apps_get_webhook_config_for_app_request(
  base: Request(a),
) -> Request(a)

pub fn apps_get_webhook_config_for_app_response(
  response: Response(BitArray),
) -> Result(Result(WebhookConfig, String), DecodeError)

pub fn apps_get_webhook_delivery_request(
  base: Request(a),
  delivery_id: Int,
) -> Request(a)

pub fn apps_get_webhook_delivery_response(
  response: Response(BitArray),
) -> Result(Result(HookDelivery, String), DecodeError)

pub fn apps_list_accounts_for_plan_request(
  base: Request(a),
  plan_id: Int,
  sort sort: Option(String),
  direction direction: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_accounts_for_plan_response(
  response: Response(BitArray),
) -> Result(
  Result(List(MarketplacePurchase), String),
  DecodeError,
)

pub fn apps_list_accounts_for_plan_stubbed_request(
  base: Request(a),
  plan_id: Int,
  sort sort: Option(String),
  direction direction: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_accounts_for_plan_stubbed_response(
  response: Response(BitArray),
) -> Result(
  Result(List(MarketplacePurchase), String),
  DecodeError,
)

pub fn apps_list_installation_repos_for_authenticated_user_request(
  base: Request(a),
  installation_id: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_installation_repos_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn apps_list_installation_requests_for_authenticated_app_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_installation_requests_for_authenticated_app_response(
  response: Response(BitArray),
) -> Result(
  Result(List(IntegrationInstallationRequest), String),
  DecodeError,
)

pub fn apps_list_installations_for_authenticated_user_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_installations_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn apps_list_installations_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
  since since: Option(String),
  outdated outdated: Option(String),
) -> Request(a)

pub fn apps_list_installations_response(
  response: Response(BitArray),
) -> Result(Result(List(Installation), String), DecodeError)

pub fn apps_list_plans_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_plans_response(
  response: Response(BitArray),
) -> Result(
  Result(List(MarketplaceListingPlan), String),
  DecodeError,
)

pub fn apps_list_plans_stubbed_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_plans_stubbed_response(
  response: Response(BitArray),
) -> Result(
  Result(List(MarketplaceListingPlan), String),
  DecodeError,
)

pub fn apps_list_repos_accessible_to_installation_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_repos_accessible_to_installation_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn apps_list_subscriptions_for_authenticated_user_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_subscriptions_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(
  Result(List(UserMarketplacePurchase), String),
  DecodeError,
)

pub fn apps_list_subscriptions_for_authenticated_user_stubbed_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn apps_list_subscriptions_for_authenticated_user_stubbed_response(
  response: Response(BitArray),
) -> Result(
  Result(List(UserMarketplacePurchase), String),
  DecodeError,
)

pub fn apps_list_webhook_deliveries_request(
  base: Request(a),
  per_page per_page: Option(Int),
  cursor cursor: Option(String),
) -> Request(a)

pub fn apps_list_webhook_deliveries_response(
  response: Response(BitArray),
) -> Result(Result(List(HookDeliveryItem), String), DecodeError)

pub fn apps_redeliver_webhook_delivery_request(
  base: Request(a),
  delivery_id: Int,
) -> Request(a)

pub fn apps_redeliver_webhook_delivery_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn apps_remove_repo_from_installation_for_authenticated_user_request(
  base: Request(a),
  installation_id: Int,
  repository_id: Int,
) -> Request(a)

pub fn apps_remove_repo_from_installation_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn apps_reset_token_request(
  base: Request(a),
  client_id: String,
  data: b,
) -> Request(b)

pub fn apps_reset_token_response(
  response: Response(BitArray),
) -> Result(Result(Authorization, String), DecodeError)

pub fn apps_revoke_installation_access_token_request(
  base: Request(a),
) -> Request(a)

pub fn apps_revoke_installation_access_token_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn apps_scope_token_request(
  base: Request(a),
  client_id: String,
  data: b,
) -> Request(b)

pub fn apps_scope_token_response(
  response: Response(BitArray),
) -> Result(Result(Authorization, String), DecodeError)

pub fn apps_suspend_installation_request(
  base: Request(a),
  installation_id: Int,
) -> Request(a)

pub fn apps_suspend_installation_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn apps_unsuspend_installation_request(
  base: Request(a),
  installation_id: Int,
) -> Request(a)

pub fn apps_unsuspend_installation_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn apps_update_webhook_config_for_app_request(
  base: Request(a),
  data: b,
) -> Request(b)

pub fn apps_update_webhook_config_for_app_response(
  response: Response(BitArray),
) -> Result(Result(WebhookConfig, String), DecodeError)

pub fn billing_get_github_actions_billing_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn billing_get_github_actions_billing_org_response(
  response: Response(BitArray),
) -> Result(Result(ActionsBillingUsage, String), DecodeError)

pub fn billing_get_github_actions_billing_user_request(
  base: Request(a),
  username: String,
) -> Request(a)

pub fn billing_get_github_actions_billing_user_response(
  response: Response(BitArray),
) -> Result(Result(ActionsBillingUsage, String), DecodeError)

pub fn billing_get_github_packages_billing_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn billing_get_github_packages_billing_org_response(
  response: Response(BitArray),
) -> Result(Result(PackagesBillingUsage, String), DecodeError)

pub fn billing_get_github_packages_billing_user_request(
  base: Request(a),
  username: String,
) -> Request(a)

pub fn billing_get_github_packages_billing_user_response(
  response: Response(BitArray),
) -> Result(Result(PackagesBillingUsage, String), DecodeError)

pub fn billing_get_shared_storage_billing_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn billing_get_shared_storage_billing_org_response(
  response: Response(BitArray),
) -> Result(Result(CombinedBillingUsage, String), DecodeError)

pub fn billing_get_shared_storage_billing_user_request(
  base: Request(a),
  username: String,
) -> Request(a)

pub fn billing_get_shared_storage_billing_user_response(
  response: Response(BitArray),
) -> Result(Result(CombinedBillingUsage, String), DecodeError)

pub fn checks_create_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn checks_create_response(
  response: Response(BitArray),
) -> Result(Result(CheckRun, String), DecodeError)

pub fn checks_create_suite_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn checks_create_suite_response(
  response: Response(BitArray),
) -> Result(Result(CheckSuite, String), DecodeError)

pub fn checks_get_request(
  base: Request(a),
  owner: String,
  repo: String,
  check_run_id: Int,
) -> Request(a)

pub fn checks_get_response(
  response: Response(BitArray),
) -> Result(Result(CheckRun, String), DecodeError)

pub fn checks_get_suite_request(
  base: Request(a),
  owner: String,
  repo: String,
  check_suite_id: Int,
) -> Request(a)

pub fn checks_get_suite_response(
  response: Response(BitArray),
) -> Result(Result(CheckSuite, String), DecodeError)

pub fn checks_list_annotations_request(
  base: Request(a),
  owner: String,
  repo: String,
  check_run_id: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn checks_list_annotations_response(
  response: Response(BitArray),
) -> Result(Result(List(CheckAnnotation), String), DecodeError)

pub fn checks_list_for_ref_request(
  base: Request(a),
  owner: String,
  repo: String,
  ref: String,
  check_name check_name: Option(String),
  status status: Option(String),
  filter filter: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
  app_id app_id: Option(Int),
) -> Request(a)

pub fn checks_list_for_ref_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn checks_list_for_suite_request(
  base: Request(a),
  owner: String,
  repo: String,
  check_suite_id: Int,
  check_name check_name: Option(String),
  status status: Option(String),
  filter filter: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn checks_list_for_suite_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn checks_list_suites_for_ref_request(
  base: Request(a),
  owner: String,
  repo: String,
  ref: String,
  app_id app_id: Option(Int),
  check_name check_name: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn checks_list_suites_for_ref_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn checks_rerequest_run_request(
  base: Request(a),
  owner: String,
  repo: String,
  check_run_id: Int,
) -> Request(a)

pub fn checks_rerequest_run_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn checks_rerequest_suite_request(
  base: Request(a),
  owner: String,
  repo: String,
  check_suite_id: Int,
) -> Request(a)

pub fn checks_rerequest_suite_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn checks_set_suites_preferences_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn checks_set_suites_preferences_response(
  response: Response(BitArray),
) -> Result(Result(CheckSuitePreference, String), DecodeError)

pub fn checks_update_request(
  base: Request(a),
  owner: String,
  repo: String,
  check_run_id: Int,
  data: b,
) -> Request(b)

pub fn checks_update_response(
  response: Response(BitArray),
) -> Result(Result(CheckRun, String), DecodeError)

pub fn classroom_get_a_classroom_request(
  base: Request(a),
  classroom_id: Int,
) -> Request(a)

pub fn classroom_get_a_classroom_response(
  response: Response(BitArray),
) -> Result(Result(Classroom, String), DecodeError)

pub fn classroom_get_an_assignment_request(
  base: Request(a),
  assignment_id: Int,
) -> Request(a)

pub fn classroom_get_an_assignment_response(
  response: Response(BitArray),
) -> Result(Result(ClassroomAssignment, String), DecodeError)

pub fn classroom_get_assignment_grades_request(
  base: Request(a),
  assignment_id: Int,
) -> Request(a)

pub fn classroom_get_assignment_grades_response(
  response: Response(BitArray),
) -> Result(
  Result(List(ClassroomAssignmentGrade), String),
  DecodeError,
)

pub fn classroom_list_accepted_assignments_for_an_assignment_request(
  base: Request(a),
  assignment_id: Int,
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn classroom_list_accepted_assignments_for_an_assignment_response(
  response: Response(BitArray),
) -> Result(
  Result(List(ClassroomAcceptedAssignment), String),
  DecodeError,
)

pub fn classroom_list_assignments_for_a_classroom_request(
  base: Request(a),
  classroom_id: Int,
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn classroom_list_assignments_for_a_classroom_response(
  response: Response(BitArray),
) -> Result(
  Result(List(SimpleClassroomAssignment), String),
  DecodeError,
)

pub fn classroom_list_classrooms_request(
  base: Request(a),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn classroom_list_classrooms_response(
  response: Response(BitArray),
) -> Result(Result(List(SimpleClassroom), String), DecodeError)

pub fn code_scanning_create_variant_analysis_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn code_scanning_create_variant_analysis_response(
  response: Response(BitArray),
) -> Result(
  Result(CodeScanningVariantAnalysis, String),
  DecodeError,
)

pub fn code_scanning_delete_analysis_request(
  base: Request(a),
  owner: String,
  repo: String,
  analysis_id: Int,
  confirm_delete confirm_delete: Option(String),
) -> Request(a)

pub fn code_scanning_delete_analysis_response(
  response: Response(BitArray),
) -> Result(
  Result(CodeScanningAnalysisDeletion, String),
  DecodeError,
)

pub fn code_scanning_delete_codeql_database_request(
  base: Request(a),
  owner: String,
  repo: String,
  language: String,
) -> Request(a)

pub fn code_scanning_delete_codeql_database_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn code_scanning_get_alert_request(
  base: Request(a),
  owner: String,
  repo: String,
  alert_number: Int,
) -> Request(a)

pub fn code_scanning_get_alert_response(
  response: Response(BitArray),
) -> Result(Result(CodeScanningAlert, String), DecodeError)

pub fn code_scanning_get_analysis_request(
  base: Request(a),
  owner: String,
  repo: String,
  analysis_id: Int,
) -> Request(a)

pub fn code_scanning_get_analysis_response(
  response: Response(BitArray),
) -> Result(Result(CodeScanningAnalysis, String), DecodeError)

pub fn code_scanning_get_codeql_database_request(
  base: Request(a),
  owner: String,
  repo: String,
  language: String,
) -> Request(a)

pub fn code_scanning_get_codeql_database_response(
  response: Response(BitArray),
) -> Result(
  Result(CodeScanningCodeqlDatabase, String),
  DecodeError,
)

pub fn code_scanning_get_default_setup_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn code_scanning_get_default_setup_response(
  response: Response(BitArray),
) -> Result(Result(CodeScanningDefaultSetup, String), DecodeError)

pub fn code_scanning_get_sarif_request(
  base: Request(a),
  owner: String,
  repo: String,
  sarif_id: String,
) -> Request(a)

pub fn code_scanning_get_sarif_response(
  response: Response(BitArray),
) -> Result(Result(CodeScanningSarifsStatus, String), DecodeError)

pub fn code_scanning_get_variant_analysis_repo_task_request(
  base: Request(a),
  owner: String,
  repo: String,
  codeql_variant_analysis_id: Int,
  repo_owner: String,
  repo_name: String,
) -> Request(a)

pub fn code_scanning_get_variant_analysis_repo_task_response(
  response: Response(BitArray),
) -> Result(
  Result(CodeScanningVariantAnalysisRepoTask, String),
  DecodeError,
)

pub fn code_scanning_get_variant_analysis_request(
  base: Request(a),
  owner: String,
  repo: String,
  codeql_variant_analysis_id: Int,
) -> Request(a)

pub fn code_scanning_get_variant_analysis_response(
  response: Response(BitArray),
) -> Result(
  Result(CodeScanningVariantAnalysis, String),
  DecodeError,
)

pub fn code_scanning_list_alert_instances_request(
  base: Request(a),
  owner: String,
  repo: String,
  alert_number: Int,
  page page: Option(Int),
  per_page per_page: Option(Int),
  ref ref: Option(String),
  pr pr: Option(Int),
) -> Request(a)

pub fn code_scanning_list_alert_instances_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CodeScanningAlertInstance), String),
  DecodeError,
)

pub fn code_scanning_list_alerts_for_org_request(
  base: Request(a),
  org: String,
  tool_name tool_name: Option(String),
  tool_guid tool_guid: Option(String),
  before before: Option(String),
  after after: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
  direction direction: Option(String),
  state state: Option(String),
  sort sort: Option(String),
  severity severity: Option(String),
) -> Request(a)

pub fn code_scanning_list_alerts_for_org_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CodeScanningOrganizationAlertItems), String),
  DecodeError,
)

pub fn code_scanning_list_alerts_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  tool_name tool_name: Option(String),
  tool_guid tool_guid: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
  ref ref: Option(String),
  pr pr: Option(Int),
  direction direction: Option(String),
  before before: Option(String),
  after after: Option(String),
  sort sort: Option(String),
  state state: Option(String),
  severity severity: Option(String),
) -> Request(a)

pub fn code_scanning_list_alerts_for_repo_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CodeScanningAlertItems), String),
  DecodeError,
)

pub fn code_scanning_list_codeql_databases_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn code_scanning_list_codeql_databases_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CodeScanningCodeqlDatabase), String),
  DecodeError,
)

pub fn code_scanning_list_recent_analyses_request(
  base: Request(a),
  owner: String,
  repo: String,
  tool_name tool_name: Option(String),
  tool_guid tool_guid: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
  pr pr: Option(Int),
  ref ref: Option(String),
  sarif_id sarif_id: Option(String),
  direction direction: Option(String),
  sort sort: Option(String),
) -> Request(a)

pub fn code_scanning_list_recent_analyses_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CodeScanningAnalysis), String),
  DecodeError,
)

pub fn code_scanning_update_alert_request(
  base: Request(a),
  owner: String,
  repo: String,
  alert_number: Int,
  data: b,
) -> Request(b)

pub fn code_scanning_update_alert_response(
  response: Response(BitArray),
) -> Result(Result(CodeScanningAlert, String), DecodeError)

pub fn code_scanning_update_default_setup_request(
  base: Request(a),
  owner: String,
  repo: String,
  code_scanning_default_setup_update: CodeScanningDefaultSetupUpdate,
) -> Request(BitArray)

pub fn code_scanning_update_default_setup_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn code_scanning_upload_sarif_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn code_scanning_upload_sarif_response(
  response: Response(BitArray),
) -> Result(
  Result(CodeScanningSarifsReceipt, String),
  DecodeError,
)

pub fn code_security_attach_configuration_request(
  base: Request(a),
  org: String,
  configuration_id: Int,
  data: b,
) -> Request(b)

pub fn code_security_attach_configuration_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn code_security_create_configuration_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn code_security_create_configuration_response(
  response: Response(BitArray),
) -> Result(
  Result(CodeSecurityConfiguration, String),
  DecodeError,
)

pub fn code_security_delete_configuration_request(
  base: Request(a),
  org: String,
  configuration_id: Int,
) -> Request(a)

pub fn code_security_delete_configuration_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn code_security_detach_configuration_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn code_security_detach_configuration_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn code_security_get_configuration_for_repository_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn code_security_get_configuration_for_repository_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn code_security_get_configuration_request(
  base: Request(a),
  org: String,
  configuration_id: Int,
) -> Request(a)

pub fn code_security_get_configuration_response(
  response: Response(BitArray),
) -> Result(
  Result(CodeSecurityConfiguration, String),
  DecodeError,
)

pub fn code_security_get_configurations_for_org_request(
  base: Request(a),
  org: String,
  target_type target_type: Option(String),
  per_page per_page: Option(Int),
  before before: Option(String),
  after after: Option(String),
) -> Request(a)

pub fn code_security_get_configurations_for_org_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CodeSecurityConfiguration), String),
  DecodeError,
)

pub fn code_security_get_default_configurations_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn code_security_get_default_configurations_response(
  response: Response(BitArray),
) -> Result(Result(a, String), DecodeError)

pub fn code_security_get_repositories_for_configuration_request(
  base: Request(a),
  org: String,
  configuration_id: Int,
  per_page per_page: Option(Int),
  before before: Option(String),
  after after: Option(String),
  status status: Option(String),
) -> Request(a)

pub fn code_security_get_repositories_for_configuration_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CodeSecurityConfigurationRepositories), String),
  DecodeError,
)

pub fn code_security_set_configuration_as_default_request(
  base: Request(a),
  org: String,
  configuration_id: Int,
  data: b,
) -> Request(b)

pub fn code_security_set_configuration_as_default_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn code_security_update_configuration_request(
  base: Request(a),
  org: String,
  configuration_id: Int,
  data: b,
) -> Request(b)

pub fn code_security_update_configuration_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codes_of_conduct_get_all_codes_of_conduct_request(
  base: Request(a),
) -> Request(a)

pub fn codes_of_conduct_get_all_codes_of_conduct_response(
  response: Response(BitArray),
) -> Result(Result(List(CodeOfConduct), String), DecodeError)

pub fn codes_of_conduct_get_conduct_code_request(
  base: Request(a),
  key: String,
) -> Request(a)

pub fn codes_of_conduct_get_conduct_code_response(
  response: Response(BitArray),
) -> Result(Result(CodeOfConduct, String), DecodeError)

pub fn codespaces_add_repository_for_secret_for_authenticated_user_request(
  base: Request(a),
  secret_name: String,
  repository_id: Int,
) -> Request(a)

pub fn codespaces_add_repository_for_secret_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_add_selected_repo_to_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  repository_id: Int,
) -> Request(a)

pub fn codespaces_add_selected_repo_to_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_check_permissions_for_devcontainer_request(
  base: Request(a),
  owner: String,
  repo: String,
  ref ref: String,
  devcontainer_path devcontainer_path: String,
) -> Request(a)

pub fn codespaces_check_permissions_for_devcontainer_response(
  response: Response(BitArray),
) -> Result(
  Result(CodespacesPermissionsCheckForDevcontainer, String),
  DecodeError,
)

pub fn codespaces_codespace_machines_for_authenticated_user_request(
  base: Request(a),
  codespace_name: String,
) -> Request(a)

pub fn codespaces_codespace_machines_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_create_for_authenticated_user_request(
  base: Request(a),
) -> Request(a)

pub fn codespaces_create_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Codespace, String), DecodeError)

pub fn codespaces_create_or_update_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn codespaces_create_or_update_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_create_or_update_repo_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn codespaces_create_or_update_repo_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_create_or_update_secret_for_authenticated_user_request(
  base: Request(a),
  secret_name: String,
  data: b,
) -> Request(b)

pub fn codespaces_create_or_update_secret_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_create_with_pr_for_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
  pull_number: Int,
  data: b,
) -> Request(b)

pub fn codespaces_create_with_pr_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Codespace, String), DecodeError)

pub fn codespaces_create_with_repo_for_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn codespaces_create_with_repo_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Codespace, String), DecodeError)

pub fn codespaces_delete_codespaces_access_users_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn codespaces_delete_codespaces_access_users_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_delete_for_authenticated_user_request(
  base: Request(a),
  codespace_name: String,
) -> Request(a)

pub fn codespaces_delete_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_delete_from_organization_request(
  base: Request(a),
  org: String,
  username: String,
  codespace_name: String,
) -> Request(a)

pub fn codespaces_delete_from_organization_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_delete_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
) -> Request(a)

pub fn codespaces_delete_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_delete_repo_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  secret_name: String,
) -> Request(a)

pub fn codespaces_delete_repo_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_delete_secret_for_authenticated_user_request(
  base: Request(a),
  secret_name: String,
) -> Request(a)

pub fn codespaces_delete_secret_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_export_for_authenticated_user_request(
  base: Request(a),
  codespace_name: String,
) -> Request(a)

pub fn codespaces_export_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(CodespaceExportDetails, String), DecodeError)

pub fn codespaces_get_codespaces_for_user_in_org_request(
  base: Request(a),
  org: String,
  username: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn codespaces_get_codespaces_for_user_in_org_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_get_export_details_for_authenticated_user_request(
  base: Request(a),
  codespace_name: String,
  export_id: String,
) -> Request(a)

pub fn codespaces_get_export_details_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(CodespaceExportDetails, String), DecodeError)

pub fn codespaces_get_for_authenticated_user_request(
  base: Request(a),
  codespace_name: String,
) -> Request(a)

pub fn codespaces_get_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Codespace, String), DecodeError)

pub fn codespaces_get_org_public_key_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn codespaces_get_org_public_key_response(
  response: Response(BitArray),
) -> Result(Result(CodespacesPublicKey, String), DecodeError)

pub fn codespaces_get_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
) -> Request(a)

pub fn codespaces_get_org_secret_response(
  response: Response(BitArray),
) -> Result(Result(CodespacesOrgSecret, String), DecodeError)

pub fn codespaces_get_public_key_for_authenticated_user_request(
  base: Request(a),
) -> Request(a)

pub fn codespaces_get_public_key_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(CodespacesUserPublicKey, String), DecodeError)

pub fn codespaces_get_repo_public_key_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn codespaces_get_repo_public_key_response(
  response: Response(BitArray),
) -> Result(Result(CodespacesPublicKey, String), DecodeError)

pub fn codespaces_get_repo_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  secret_name: String,
) -> Request(a)

pub fn codespaces_get_repo_secret_response(
  response: Response(BitArray),
) -> Result(Result(RepoCodespacesSecret, String), DecodeError)

pub fn codespaces_get_secret_for_authenticated_user_request(
  base: Request(a),
  secret_name: String,
) -> Request(a)

pub fn codespaces_get_secret_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(CodespacesSecret, String), DecodeError)

pub fn codespaces_list_devcontainers_in_repository_for_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn codespaces_list_devcontainers_in_repository_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_list_for_authenticated_user_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
  repository_id repository_id: Option(Int),
) -> Request(a)

pub fn codespaces_list_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_list_in_organization_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn codespaces_list_in_organization_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_list_in_repository_for_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn codespaces_list_in_repository_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_list_org_secrets_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn codespaces_list_org_secrets_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_list_repo_secrets_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn codespaces_list_repo_secrets_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_list_repositories_for_secret_for_authenticated_user_request(
  base: Request(a),
  secret_name: String,
) -> Request(a)

pub fn codespaces_list_repositories_for_secret_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_list_secrets_for_authenticated_user_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn codespaces_list_secrets_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_list_selected_repos_for_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn codespaces_list_selected_repos_for_org_secret_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_pre_flight_with_repo_for_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
  ref ref: Option(String),
  client_ip client_ip: Option(String),
) -> Request(a)

pub fn codespaces_pre_flight_with_repo_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_publish_for_authenticated_user_request(
  base: Request(a),
  codespace_name: String,
  data: b,
) -> Request(b)

pub fn codespaces_publish_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(
  Result(CodespaceWithFullRepository, String),
  DecodeError,
)

pub fn codespaces_remove_repository_for_secret_for_authenticated_user_request(
  base: Request(a),
  secret_name: String,
  repository_id: Int,
) -> Request(a)

pub fn codespaces_remove_repository_for_secret_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_remove_selected_repo_from_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  repository_id: Int,
) -> Request(a)

pub fn codespaces_remove_selected_repo_from_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_repo_machines_for_authenticated_user_request(
  base: Request(a),
  owner: String,
  repo: String,
  location location: Option(String),
  client_ip client_ip: Option(String),
  ref ref: Option(String),
) -> Request(a)

pub fn codespaces_repo_machines_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn codespaces_set_codespaces_access_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn codespaces_set_codespaces_access_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_set_codespaces_access_users_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn codespaces_set_codespaces_access_users_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_set_repositories_for_secret_for_authenticated_user_request(
  base: Request(a),
  secret_name: String,
  data: b,
) -> Request(b)

pub fn codespaces_set_repositories_for_secret_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_set_selected_repos_for_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn codespaces_set_selected_repos_for_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn codespaces_start_for_authenticated_user_request(
  base: Request(a),
  codespace_name: String,
) -> Request(a)

pub fn codespaces_start_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Codespace, String), DecodeError)

pub fn codespaces_stop_for_authenticated_user_request(
  base: Request(a),
  codespace_name: String,
) -> Request(a)

pub fn codespaces_stop_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Codespace, String), DecodeError)

pub fn codespaces_stop_in_organization_request(
  base: Request(a),
  org: String,
  username: String,
  codespace_name: String,
) -> Request(a)

pub fn codespaces_stop_in_organization_response(
  response: Response(BitArray),
) -> Result(Result(Codespace, String), DecodeError)

pub fn codespaces_update_for_authenticated_user_request(
  base: Request(a),
  codespace_name: String,
  data: b,
) -> Request(b)

pub fn codespaces_update_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Codespace, String), DecodeError)

pub fn copilot_add_copilot_seats_for_teams_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn copilot_add_copilot_seats_for_teams_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn copilot_add_copilot_seats_for_users_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn copilot_add_copilot_seats_for_users_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn copilot_cancel_copilot_seat_assignment_for_teams_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn copilot_cancel_copilot_seat_assignment_for_teams_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn copilot_cancel_copilot_seat_assignment_for_users_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn copilot_cancel_copilot_seat_assignment_for_users_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn copilot_copilot_metrics_for_enterprise_request(
  base: Request(a),
  enterprise: String,
  since since: Option(String),
  until until: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_copilot_metrics_for_enterprise_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CopilotUsageMetricsDay), String),
  DecodeError,
)

pub fn copilot_copilot_metrics_for_enterprise_team_request(
  base: Request(a),
  enterprise: String,
  team_slug: String,
  since since: Option(String),
  until until: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_copilot_metrics_for_enterprise_team_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CopilotUsageMetricsDay), String),
  DecodeError,
)

pub fn copilot_copilot_metrics_for_organization_request(
  base: Request(a),
  org: String,
  since since: Option(String),
  until until: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_copilot_metrics_for_organization_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CopilotUsageMetricsDay), String),
  DecodeError,
)

pub fn copilot_copilot_metrics_for_team_request(
  base: Request(a),
  org: String,
  team_slug: String,
  since since: Option(String),
  until until: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_copilot_metrics_for_team_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CopilotUsageMetricsDay), String),
  DecodeError,
)

pub fn copilot_get_copilot_organization_details_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn copilot_get_copilot_organization_details_response(
  response: Response(BitArray),
) -> Result(
  Result(CopilotOrganizationDetails, String),
  DecodeError,
)

pub fn copilot_get_copilot_seat_details_for_user_request(
  base: Request(a),
  org: String,
  username: String,
) -> Request(a)

pub fn copilot_get_copilot_seat_details_for_user_response(
  response: Response(BitArray),
) -> Result(Result(CopilotSeatDetails, String), DecodeError)

pub fn copilot_list_copilot_seats_for_enterprise_request(
  base: Request(a),
  enterprise: String,
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_list_copilot_seats_for_enterprise_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn copilot_list_copilot_seats_request(
  base: Request(a),
  org: String,
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_list_copilot_seats_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn copilot_usage_metrics_for_enterprise_request(
  base: Request(a),
  enterprise: String,
  since since: Option(String),
  until until: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_usage_metrics_for_enterprise_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CopilotUsageMetrics), String),
  DecodeError,
)

pub fn copilot_usage_metrics_for_enterprise_team_request(
  base: Request(a),
  enterprise: String,
  team_slug: String,
  since since: Option(String),
  until until: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_usage_metrics_for_enterprise_team_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CopilotUsageMetrics), String),
  DecodeError,
)

pub fn copilot_usage_metrics_for_org_request(
  base: Request(a),
  org: String,
  since since: Option(String),
  until until: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_usage_metrics_for_org_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CopilotUsageMetrics), String),
  DecodeError,
)

pub fn copilot_usage_metrics_for_team_request(
  base: Request(a),
  org: String,
  team_slug: String,
  since since: Option(String),
  until until: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn copilot_usage_metrics_for_team_response(
  response: Response(BitArray),
) -> Result(
  Result(List(CopilotUsageMetrics), String),
  DecodeError,
)

pub fn dependabot_add_selected_repo_to_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  repository_id: Int,
) -> Request(a)

pub fn dependabot_add_selected_repo_to_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn dependabot_create_or_update_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn dependabot_create_or_update_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn dependabot_create_or_update_repo_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn dependabot_create_or_update_repo_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn dependabot_delete_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
) -> Request(a)

pub fn dependabot_delete_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn dependabot_delete_repo_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  secret_name: String,
) -> Request(a)

pub fn dependabot_delete_repo_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn dependabot_get_alert_request(
  base: Request(a),
  owner: String,
  repo: String,
  alert_number: Int,
) -> Request(a)

pub fn dependabot_get_alert_response(
  response: Response(BitArray),
) -> Result(Result(DependabotAlert, String), DecodeError)

pub fn dependabot_get_org_public_key_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn dependabot_get_org_public_key_response(
  response: Response(BitArray),
) -> Result(Result(DependabotPublicKey, String), DecodeError)

pub fn dependabot_get_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
) -> Request(a)

pub fn dependabot_get_org_secret_response(
  response: Response(BitArray),
) -> Result(
  Result(OrganizationDependabotSecret, String),
  DecodeError,
)

pub fn dependabot_get_repo_public_key_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn dependabot_get_repo_public_key_response(
  response: Response(BitArray),
) -> Result(Result(DependabotPublicKey, String), DecodeError)

pub fn dependabot_get_repo_secret_request(
  base: Request(a),
  owner: String,
  repo: String,
  secret_name: String,
) -> Request(a)

pub fn dependabot_get_repo_secret_response(
  response: Response(BitArray),
) -> Result(Result(DependabotSecret, String), DecodeError)

pub fn dependabot_list_alerts_for_enterprise_request(
  base: Request(a),
  enterprise: String,
  state state: Option(String),
  severity severity: Option(String),
  ecosystem ecosystem: Option(String),
  package package: Option(String),
  scope scope: Option(String),
  sort sort: Option(String),
  direction direction: Option(String),
  before before: Option(String),
  after after: Option(String),
  first first: Option(Int),
  last last: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn dependabot_list_alerts_for_enterprise_response(
  response: Response(BitArray),
) -> Result(
  Result(List(DependabotAlertWithRepository), String),
  DecodeError,
)

pub fn dependabot_list_alerts_for_org_request(
  base: Request(a),
  org: String,
  state state: Option(String),
  severity severity: Option(String),
  ecosystem ecosystem: Option(String),
  package package: Option(String),
  scope scope: Option(String),
  sort sort: Option(String),
  direction direction: Option(String),
  before before: Option(String),
  after after: Option(String),
  first first: Option(Int),
  last last: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn dependabot_list_alerts_for_org_response(
  response: Response(BitArray),
) -> Result(
  Result(List(DependabotAlertWithRepository), String),
  DecodeError,
)

pub fn dependabot_list_alerts_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  state state: Option(String),
  severity severity: Option(String),
  ecosystem ecosystem: Option(String),
  package package: Option(String),
  manifest manifest: Option(String),
  scope scope: Option(String),
  sort sort: Option(String),
  direction direction: Option(String),
  page page: Option(Int),
  per_page per_page: Option(Int),
  before before: Option(String),
  after after: Option(String),
  first first: Option(Int),
  last last: Option(Int),
) -> Request(a)

pub fn dependabot_list_alerts_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(List(DependabotAlert), String), DecodeError)

pub fn dependabot_list_org_secrets_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn dependabot_list_org_secrets_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn dependabot_list_repo_secrets_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn dependabot_list_repo_secrets_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn dependabot_list_selected_repos_for_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  page page: Option(Int),
  per_page per_page: Option(Int),
) -> Request(a)

pub fn dependabot_list_selected_repos_for_org_secret_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn dependabot_remove_selected_repo_from_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  repository_id: Int,
) -> Request(a)

pub fn dependabot_remove_selected_repo_from_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn dependabot_set_selected_repos_for_org_secret_request(
  base: Request(a),
  org: String,
  secret_name: String,
  data: b,
) -> Request(b)

pub fn dependabot_set_selected_repos_for_org_secret_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn dependabot_update_alert_request(
  base: Request(a),
  owner: String,
  repo: String,
  alert_number: Int,
  data: b,
) -> Request(b)

pub fn dependabot_update_alert_response(
  response: Response(BitArray),
) -> Result(Result(DependabotAlert, String), DecodeError)

pub fn dependency_graph_create_repository_snapshot_request(
  base: Request(a),
  owner: String,
  repo: String,
  snapshot: Snapshot,
) -> Request(BitArray)

pub fn dependency_graph_create_repository_snapshot_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn dependency_graph_diff_range_request(
  base: Request(a),
  owner: String,
  repo: String,
  basehead: String,
  name name: Option(String),
) -> Request(a)

pub fn dependency_graph_diff_range_response(
  response: Response(BitArray),
) -> Result(Result(a, String), DecodeError)

pub fn dependency_graph_export_sbom_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn dependency_graph_export_sbom_response(
  response: Response(BitArray),
) -> Result(Result(DependencyGraphSpdxSbom, String), DecodeError)

pub fn emojis_get_request(base: Request(a)) -> Request(a)

pub fn emojis_get_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn gists_check_is_starred_request(
  base: Request(a),
  gist_id: String,
) -> Request(a)

pub fn gists_check_is_starred_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn gists_create_comment_request(
  base: Request(a),
  gist_id: String,
  data: b,
) -> Request(b)

pub fn gists_create_comment_response(
  response: Response(BitArray),
) -> Result(Result(GistComment, String), DecodeError)

pub fn gists_create_request(
  base: Request(a),
  data: b,
) -> Request(b)

pub fn gists_create_response(
  response: Response(BitArray),
) -> Result(Result(GistSimple, String), DecodeError)

pub fn gists_delete_comment_request(
  base: Request(a),
  gist_id: String,
  comment_id: Int,
) -> Request(a)

pub fn gists_delete_comment_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn gists_delete_request(
  base: Request(a),
  gist_id: String,
) -> Request(a)

pub fn gists_delete_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn gists_fork_request(
  base: Request(a),
  gist_id: String,
) -> Request(a)

pub fn gists_fork_response(
  response: Response(BitArray),
) -> Result(Result(BaseGist, String), DecodeError)

pub fn gists_get_comment_request(
  base: Request(a),
  gist_id: String,
  comment_id: Int,
) -> Request(a)

pub fn gists_get_comment_response(
  response: Response(BitArray),
) -> Result(Result(GistComment, String), DecodeError)

pub fn gists_get_request(
  base: Request(a),
  gist_id: String,
) -> Request(a)

pub fn gists_get_response(
  response: Response(BitArray),
) -> Result(Result(GistSimple, String), DecodeError)

pub fn gists_get_revision_request(
  base: Request(a),
  gist_id: String,
  sha: String,
) -> Request(a)

pub fn gists_get_revision_response(
  response: Response(BitArray),
) -> Result(Result(GistSimple, String), DecodeError)

pub fn gists_list_comments_request(
  base: Request(a),
  gist_id: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn gists_list_comments_response(
  response: Response(BitArray),
) -> Result(Result(List(GistComment), String), DecodeError)

pub fn gists_list_commits_request(
  base: Request(a),
  gist_id: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn gists_list_commits_response(
  response: Response(BitArray),
) -> Result(Result(List(GistCommit), String), DecodeError)

pub fn gists_list_for_user_request(
  base: Request(a),
  username: String,
  since since: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn gists_list_for_user_response(
  response: Response(BitArray),
) -> Result(Result(List(BaseGist), String), DecodeError)

pub fn gists_list_forks_request(
  base: Request(a),
  gist_id: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn gists_list_forks_response(
  response: Response(BitArray),
) -> Result(Result(List(GistSimple), String), DecodeError)

pub fn gists_list_public_request(
  base: Request(a),
  since since: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn gists_list_public_response(
  response: Response(BitArray),
) -> Result(Result(List(BaseGist), String), DecodeError)

pub fn gists_list_request(
  base: Request(a),
  since since: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn gists_list_response(
  response: Response(BitArray),
) -> Result(Result(List(BaseGist), String), DecodeError)

pub fn gists_list_starred_request(
  base: Request(a),
  since since: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn gists_list_starred_response(
  response: Response(BitArray),
) -> Result(Result(List(BaseGist), String), DecodeError)

pub fn gists_star_request(
  base: Request(a),
  gist_id: String,
) -> Request(a)

pub fn gists_star_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn gists_unstar_request(
  base: Request(a),
  gist_id: String,
) -> Request(a)

pub fn gists_unstar_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn gists_update_comment_request(
  base: Request(a),
  gist_id: String,
  comment_id: Int,
  data: b,
) -> Request(b)

pub fn gists_update_comment_response(
  response: Response(BitArray),
) -> Result(Result(GistComment, String), DecodeError)

pub fn gists_update_request(
  base: Request(a),
  gist_id: String,
  data: b,
) -> Request(b)

pub fn gists_update_response(
  response: Response(BitArray),
) -> Result(Result(GistSimple, String), DecodeError)

pub fn git_create_blob_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn git_create_blob_response(
  response: Response(BitArray),
) -> Result(Result(ShortBlob, String), DecodeError)

pub fn git_create_commit_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn git_create_commit_response(
  response: Response(BitArray),
) -> Result(Result(GitCommit, String), DecodeError)

pub fn git_create_ref_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn git_create_ref_response(
  response: Response(BitArray),
) -> Result(Result(GitRef, String), DecodeError)

pub fn git_create_tag_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn git_create_tag_response(
  response: Response(BitArray),
) -> Result(Result(GitTag, String), DecodeError)

pub fn git_create_tree_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn git_create_tree_response(
  response: Response(BitArray),
) -> Result(Result(GitTree, String), DecodeError)

pub fn git_delete_ref_request(
  base: Request(a),
  owner: String,
  repo: String,
  ref: String,
) -> Request(a)

pub fn git_delete_ref_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn git_get_blob_request(
  base: Request(a),
  owner: String,
  repo: String,
  file_sha: String,
) -> Request(a)

pub fn git_get_blob_response(
  response: Response(BitArray),
) -> Result(Result(Blob, String), DecodeError)

pub fn git_get_commit_request(
  base: Request(a),
  owner: String,
  repo: String,
  commit_sha: String,
) -> Request(a)

pub fn git_get_commit_response(
  response: Response(BitArray),
) -> Result(Result(GitCommit, String), DecodeError)

pub fn git_get_ref_request(
  base: Request(a),
  owner: String,
  repo: String,
  ref: String,
) -> Request(a)

pub fn git_get_ref_response(
  response: Response(BitArray),
) -> Result(Result(GitRef, String), DecodeError)

pub fn git_get_tag_request(
  base: Request(a),
  owner: String,
  repo: String,
  tag_sha: String,
) -> Request(a)

pub fn git_get_tag_response(
  response: Response(BitArray),
) -> Result(Result(GitTag, String), DecodeError)

pub fn git_get_tree_request(
  base: Request(a),
  owner: String,
  repo: String,
  tree_sha: String,
  recursive recursive: Option(String),
) -> Request(a)

pub fn git_get_tree_response(
  response: Response(BitArray),
) -> Result(Result(GitTree, String), DecodeError)

pub fn git_list_matching_refs_request(
  base: Request(a),
  owner: String,
  repo: String,
  ref: String,
) -> Request(a)

pub fn git_list_matching_refs_response(
  response: Response(BitArray),
) -> Result(Result(List(GitRef), String), DecodeError)

pub fn git_update_ref_request(
  base: Request(a),
  owner: String,
  repo: String,
  ref: String,
  data: b,
) -> Request(b)

pub fn git_update_ref_response(
  response: Response(BitArray),
) -> Result(Result(GitRef, String), DecodeError)

pub fn gitignore_get_all_templates_request(
  base: Request(a),
) -> Request(a)

pub fn gitignore_get_all_templates_response(
  response: Response(BitArray),
) -> Result(Result(Nil, String), DecodeError)

pub fn gitignore_get_template_request(
  base: Request(a),
  name: String,
) -> Request(a)

pub fn gitignore_get_template_response(
  response: Response(BitArray),
) -> Result(Result(GitignoreTemplate, String), DecodeError)

pub fn interactions_get_restrictions_for_authenticated_user_request(
  base: Request(a),
) -> Request(a)

pub fn interactions_get_restrictions_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn interactions_get_restrictions_for_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn interactions_get_restrictions_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Nil, String), DecodeError)

pub fn interactions_get_restrictions_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn interactions_get_restrictions_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(Nil, String), DecodeError)

pub fn interactions_remove_restrictions_for_authenticated_user_request(
  base: Request(a),
) -> Request(a)

pub fn interactions_remove_restrictions_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn interactions_remove_restrictions_for_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn interactions_remove_restrictions_for_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn interactions_remove_restrictions_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn interactions_remove_restrictions_for_repo_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn interactions_set_restrictions_for_authenticated_user_request(
  base: Request(a),
  interaction_limit: InteractionLimit,
) -> Request(BitArray)

pub fn interactions_set_restrictions_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(InteractionLimitResponse, String), DecodeError)

pub fn interactions_set_restrictions_for_org_request(
  base: Request(a),
  org: String,
  interaction_limit: InteractionLimit,
) -> Request(BitArray)

pub fn interactions_set_restrictions_for_org_response(
  response: Response(BitArray),
) -> Result(Result(InteractionLimitResponse, String), DecodeError)

pub fn interactions_set_restrictions_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  interaction_limit: InteractionLimit,
) -> Request(BitArray)

pub fn interactions_set_restrictions_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(InteractionLimitResponse, String), DecodeError)

pub fn issues_add_assignees_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  data: b,
) -> Request(b)

pub fn issues_add_assignees_response(
  response: Response(BitArray),
) -> Result(Result(Issue, String), DecodeError)

pub fn issues_add_labels_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
) -> Request(a)

pub fn issues_add_labels_response(
  response: Response(BitArray),
) -> Result(Result(List(Label), String), DecodeError)

pub fn issues_check_user_can_be_assigned_request(
  base: Request(a),
  owner: String,
  repo: String,
  assignee: String,
) -> Request(a)

pub fn issues_check_user_can_be_assigned_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn issues_check_user_can_be_assigned_to_issue_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  assignee: String,
) -> Request(a)

pub fn issues_check_user_can_be_assigned_to_issue_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn issues_create_comment_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  data: b,
) -> Request(b)

pub fn issues_create_comment_response(
  response: Response(BitArray),
) -> Result(Result(IssueComment, String), DecodeError)

pub fn issues_create_label_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn issues_create_label_response(
  response: Response(BitArray),
) -> Result(Result(Label, String), DecodeError)

pub fn issues_create_milestone_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn issues_create_milestone_response(
  response: Response(BitArray),
) -> Result(Result(Milestone, String), DecodeError)

pub fn issues_create_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn issues_create_response(
  response: Response(BitArray),
) -> Result(Result(Issue, String), DecodeError)

pub fn issues_delete_comment_request(
  base: Request(a),
  owner: String,
  repo: String,
  comment_id: Int,
) -> Request(a)

pub fn issues_delete_comment_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn issues_delete_label_request(
  base: Request(a),
  owner: String,
  repo: String,
  name: String,
) -> Request(a)

pub fn issues_delete_label_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn issues_delete_milestone_request(
  base: Request(a),
  owner: String,
  repo: String,
  milestone_number: Int,
) -> Request(a)

pub fn issues_delete_milestone_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn issues_get_comment_request(
  base: Request(a),
  owner: String,
  repo: String,
  comment_id: Int,
) -> Request(a)

pub fn issues_get_comment_response(
  response: Response(BitArray),
) -> Result(Result(IssueComment, String), DecodeError)

pub fn issues_get_event_request(
  base: Request(a),
  owner: String,
  repo: String,
  event_id: Int,
) -> Request(a)

pub fn issues_get_event_response(
  response: Response(BitArray),
) -> Result(Result(IssueEvent, String), DecodeError)

pub fn issues_get_label_request(
  base: Request(a),
  owner: String,
  repo: String,
  name: String,
) -> Request(a)

pub fn issues_get_label_response(
  response: Response(BitArray),
) -> Result(Result(Label, String), DecodeError)

pub fn issues_get_milestone_request(
  base: Request(a),
  owner: String,
  repo: String,
  milestone_number: Int,
) -> Request(a)

pub fn issues_get_milestone_response(
  response: Response(BitArray),
) -> Result(Result(Milestone, String), DecodeError)

pub fn issues_get_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
) -> Request(a)

pub fn issues_get_response(
  response: Response(BitArray),
) -> Result(Result(Issue, String), DecodeError)

pub fn issues_list_assignees_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_assignees_response(
  response: Response(BitArray),
) -> Result(Result(List(SimpleUser), String), DecodeError)

pub fn issues_list_comments_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  sort sort: Option(String),
  direction direction: Option(String),
  since since: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_comments_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(List(IssueComment), String), DecodeError)

pub fn issues_list_comments_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  since since: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_comments_response(
  response: Response(BitArray),
) -> Result(Result(List(IssueComment), String), DecodeError)

pub fn issues_list_events_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_events_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(List(IssueEvent), String), DecodeError)

pub fn issues_list_events_for_timeline_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_events_for_timeline_response(
  response: Response(BitArray),
) -> Result(
  Result(List(TimelineIssueEvents), String),
  DecodeError,
)

pub fn issues_list_events_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_events_response(
  response: Response(BitArray),
) -> Result(Result(List(a), String), DecodeError)

pub fn issues_list_for_authenticated_user_request(
  base: Request(a),
  filter filter: Option(String),
  state state: Option(String),
  labels labels: Option(String),
  sort sort: Option(String),
  direction direction: Option(String),
  since since: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Issue), String), DecodeError)

pub fn issues_list_for_org_request(
  base: Request(a),
  org: String,
  filter filter: Option(String),
  state state: Option(String),
  labels labels: Option(String),
  sort sort: Option(String),
  direction direction: Option(String),
  since since: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_for_org_response(
  response: Response(BitArray),
) -> Result(Result(List(Issue), String), DecodeError)

pub fn issues_list_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  milestone milestone: Option(String),
  state state: Option(String),
  assignee assignee: Option(String),
  creator creator: Option(String),
  mentioned mentioned: Option(String),
  labels labels: Option(String),
  sort sort: Option(String),
  direction direction: Option(String),
  since since: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(List(Issue), String), DecodeError)

pub fn issues_list_labels_for_milestone_request(
  base: Request(a),
  owner: String,
  repo: String,
  milestone_number: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_labels_for_milestone_response(
  response: Response(BitArray),
) -> Result(Result(List(Label), String), DecodeError)

pub fn issues_list_labels_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_labels_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(List(Label), String), DecodeError)

pub fn issues_list_labels_on_issue_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_labels_on_issue_response(
  response: Response(BitArray),
) -> Result(Result(List(Label), String), DecodeError)

pub fn issues_list_milestones_request(
  base: Request(a),
  owner: String,
  repo: String,
  state state: Option(String),
  sort sort: Option(String),
  direction direction: Option(String),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_milestones_response(
  response: Response(BitArray),
) -> Result(Result(List(Milestone), String), DecodeError)

pub fn issues_list_request(
  base: Request(a),
  filter filter: Option(String),
  state state: Option(String),
  labels labels: Option(String),
  sort sort: Option(String),
  direction direction: Option(String),
  since since: Option(String),
  collab collab: Option(Bool),
  orgs orgs: Option(Bool),
  owned owned: Option(Bool),
  pulls pulls: Option(Bool),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn issues_list_response(
  response: Response(BitArray),
) -> Result(Result(List(Issue), String), DecodeError)

pub fn issues_lock_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  data: b,
) -> Request(b)

pub fn issues_lock_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn issues_remove_all_labels_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
) -> Request(a)

pub fn issues_remove_all_labels_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn issues_remove_assignees_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  data: b,
) -> Request(b)

pub fn issues_remove_assignees_response(
  response: Response(BitArray),
) -> Result(Result(Issue, String), DecodeError)

pub fn issues_remove_label_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  name: String,
) -> Request(a)

pub fn issues_remove_label_response(
  response: Response(BitArray),
) -> Result(Result(List(Label), String), DecodeError)

pub fn issues_set_labels_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
) -> Request(a)

pub fn issues_set_labels_response(
  response: Response(BitArray),
) -> Result(Result(List(Label), String), DecodeError)

pub fn issues_unlock_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
) -> Request(a)

pub fn issues_unlock_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn issues_update_comment_request(
  base: Request(a),
  owner: String,
  repo: String,
  comment_id: Int,
  data: b,
) -> Request(b)

pub fn issues_update_comment_response(
  response: Response(BitArray),
) -> Result(Result(IssueComment, String), DecodeError)

pub fn issues_update_label_request(
  base: Request(a),
  owner: String,
  repo: String,
  name: String,
  data: b,
) -> Request(b)

pub fn issues_update_label_response(
  response: Response(BitArray),
) -> Result(Result(Label, String), DecodeError)

pub fn issues_update_milestone_request(
  base: Request(a),
  owner: String,
  repo: String,
  milestone_number: Int,
  data: b,
) -> Request(b)

pub fn issues_update_milestone_response(
  response: Response(BitArray),
) -> Result(Result(Milestone, String), DecodeError)

pub fn issues_update_request(
  base: Request(a),
  owner: String,
  repo: String,
  issue_number: Int,
  data: b,
) -> Request(b)

pub fn issues_update_response(
  response: Response(BitArray),
) -> Result(Result(Issue, String), DecodeError)

pub fn licenses_get_all_commonly_used_request(
  base: Request(a),
  featured featured: Option(Bool),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn licenses_get_all_commonly_used_response(
  response: Response(BitArray),
) -> Result(Result(List(LicenseSimple), String), DecodeError)

pub fn licenses_get_for_repo_request(
  base: Request(a),
  owner: String,
  repo: String,
  ref ref: Option(String),
) -> Request(a)

pub fn licenses_get_for_repo_response(
  response: Response(BitArray),
) -> Result(Result(LicenseContent, String), DecodeError)

pub fn licenses_get_request(
  base: Request(a),
  license: String,
) -> Request(a)

pub fn licenses_get_response(
  response: Response(BitArray),
) -> Result(Result(License, String), DecodeError)

pub fn markdown_render_raw_request(
  base: Request(a),
) -> Request(a)

pub fn markdown_render_raw_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn markdown_render_request(
  base: Request(a),
  data: b,
) -> Request(b)

pub fn markdown_render_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn meta_get_all_versions_request(
  base: Request(a),
) -> Request(a)

pub fn meta_get_all_versions_response(
  response: Response(BitArray),
) -> Result(Result(Nil, String), DecodeError)

pub fn meta_get_octocat_request(
  base: Request(a),
  s s: Option(String),
) -> Request(a)

pub fn meta_get_octocat_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn meta_get_request(base: Request(a)) -> Request(a)

pub fn meta_get_response(
  response: Response(BitArray),
) -> Result(Result(ApiOverview, String), DecodeError)

pub fn meta_get_zen_request(base: Request(a)) -> Request(a)

pub fn meta_get_zen_response(
  response: Response(BitArray),
) -> Result(Result(Nil, String), DecodeError)

pub fn meta_root_request(base: Request(a)) -> Request(a)

pub fn meta_root_response(
  response: Response(BitArray),
) -> Result(Result(Root, String), DecodeError)

pub fn migrations_cancel_import_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn migrations_cancel_import_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn migrations_delete_archive_for_authenticated_user_request(
  base: Request(a),
  migration_id: Int,
) -> Request(a)

pub fn migrations_delete_archive_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn migrations_delete_archive_for_org_request(
  base: Request(a),
  org: String,
  migration_id: Int,
) -> Request(a)

pub fn migrations_delete_archive_for_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn migrations_download_archive_for_org_request(
  base: Request(a),
  org: String,
  migration_id: Int,
) -> Request(a)

pub fn migrations_download_archive_for_org_response(
  response: Response(a),
) -> Result(Result(b, String), c)

pub fn migrations_get_archive_for_authenticated_user_request(
  base: Request(a),
  migration_id: Int,
) -> Request(a)

pub fn migrations_get_archive_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(b, String), c)

pub fn migrations_get_commit_authors_request(
  base: Request(a),
  owner: String,
  repo: String,
  since since: Option(Int),
) -> Request(a)

pub fn migrations_get_commit_authors_response(
  response: Response(BitArray),
) -> Result(Result(List(PorterAuthor), String), DecodeError)

pub fn migrations_get_import_status_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn migrations_get_import_status_response(
  response: Response(BitArray),
) -> Result(Result(Import, String), DecodeError)

pub fn migrations_get_large_files_request(
  base: Request(a),
  owner: String,
  repo: String,
) -> Request(a)

pub fn migrations_get_large_files_response(
  response: Response(BitArray),
) -> Result(Result(List(PorterLargeFile), String), DecodeError)

pub fn migrations_get_status_for_authenticated_user_request(
  base: Request(a),
  migration_id: Int,
  exclude exclude: b,
) -> Request(a)

pub fn migrations_get_status_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Migration, String), DecodeError)

pub fn migrations_get_status_for_org_request(
  base: Request(a),
  org: String,
  migration_id: Int,
  exclude exclude: b,
) -> Request(a)

pub fn migrations_get_status_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Migration, String), DecodeError)

pub fn migrations_list_for_authenticated_user_request(
  base: Request(a),
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn migrations_list_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(List(Migration), String), DecodeError)

pub fn migrations_list_for_org_request(
  base: Request(a),
  org: String,
  per_page per_page: Option(Int),
  page page: Option(Int),
  exclude exclude: b,
) -> Request(a)

pub fn migrations_list_for_org_response(
  response: Response(BitArray),
) -> Result(Result(List(Migration), String), DecodeError)

pub fn migrations_list_repos_for_authenticated_user_request(
  base: Request(a),
  migration_id: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn migrations_list_repos_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(List(MinimalRepository), String), DecodeError)

pub fn migrations_list_repos_for_org_request(
  base: Request(a),
  org: String,
  migration_id: Int,
  per_page per_page: Option(Int),
  page page: Option(Int),
) -> Request(a)

pub fn migrations_list_repos_for_org_response(
  response: Response(BitArray),
) -> Result(Result(List(MinimalRepository), String), DecodeError)

pub fn migrations_map_commit_author_request(
  base: Request(a),
  owner: String,
  repo: String,
  author_id: Int,
  data: b,
) -> Request(b)

pub fn migrations_map_commit_author_response(
  response: Response(BitArray),
) -> Result(Result(PorterAuthor, String), DecodeError)

pub fn migrations_set_lfs_preference_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn migrations_set_lfs_preference_response(
  response: Response(BitArray),
) -> Result(Result(Import, String), DecodeError)

pub fn migrations_start_for_authenticated_user_request(
  base: Request(a),
  data: b,
) -> Request(b)

pub fn migrations_start_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(Migration, String), DecodeError)

pub fn migrations_start_for_org_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn migrations_start_for_org_response(
  response: Response(BitArray),
) -> Result(Result(Migration, String), DecodeError)

pub fn migrations_start_import_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn migrations_start_import_response(
  response: Response(BitArray),
) -> Result(Result(Import, String), DecodeError)

pub fn migrations_unlock_repo_for_authenticated_user_request(
  base: Request(a),
  migration_id: Int,
  repo_name: String,
) -> Request(a)

pub fn migrations_unlock_repo_for_authenticated_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn migrations_unlock_repo_for_org_request(
  base: Request(a),
  org: String,
  migration_id: Int,
  repo_name: String,
) -> Request(a)

pub fn migrations_unlock_repo_for_org_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn migrations_update_import_request(
  base: Request(a),
  owner: String,
  repo: String,
  data: b,
) -> Request(b)

pub fn migrations_update_import_response(
  response: Response(BitArray),
) -> Result(Result(Import, String), DecodeError)

pub fn oidc_get_oidc_custom_sub_template_for_org_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn oidc_get_oidc_custom_sub_template_for_org_response(
  response: Response(BitArray),
) -> Result(Result(OidcCustomSub, String), DecodeError)

pub fn oidc_update_oidc_custom_sub_template_for_org_request(
  base: Request(a),
  org: String,
  oidc_custom_sub: OidcCustomSub,
) -> Request(BitArray)

pub fn oidc_update_oidc_custom_sub_template_for_org_response(
  response: Response(BitArray),
) -> Result(Result(EmptyObject, String), DecodeError)

pub fn orgs_add_security_manager_team_request(
  base: Request(a),
  org: String,
  team_slug: String,
) -> Request(a)

pub fn orgs_add_security_manager_team_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_assign_team_to_org_role_request(
  base: Request(a),
  org: String,
  team_slug: String,
  role_id: Int,
) -> Request(a)

pub fn orgs_assign_team_to_org_role_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_assign_user_to_org_role_request(
  base: Request(a),
  org: String,
  username: String,
  role_id: Int,
) -> Request(a)

pub fn orgs_assign_user_to_org_role_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_block_user_request(
  base: Request(a),
  org: String,
  username: String,
) -> Request(a)

pub fn orgs_block_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_cancel_invitation_request(
  base: Request(a),
  org: String,
  invitation_id: Int,
) -> Request(a)

pub fn orgs_cancel_invitation_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_check_blocked_user_request(
  base: Request(a),
  org: String,
  username: String,
) -> Request(a)

pub fn orgs_check_blocked_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_check_membership_for_user_request(
  base: Request(a),
  org: String,
  username: String,
) -> Request(a)

pub fn orgs_check_membership_for_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_check_public_membership_for_user_request(
  base: Request(a),
  org: String,
  username: String,
) -> Request(a)

pub fn orgs_check_public_membership_for_user_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_convert_member_to_outside_collaborator_request(
  base: Request(a),
  org: String,
  username: String,
  data: b,
) -> Request(b)

pub fn orgs_convert_member_to_outside_collaborator_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_create_invitation_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn orgs_create_invitation_response(
  response: Response(BitArray),
) -> Result(Result(OrganizationInvitation, String), DecodeError)

pub fn orgs_create_or_update_custom_properties_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn orgs_create_or_update_custom_properties_response(
  response: Response(BitArray),
) -> Result(Result(List(CustomProperty), String), DecodeError)

pub fn orgs_create_or_update_custom_properties_values_for_repos_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn orgs_create_or_update_custom_properties_values_for_repos_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_create_or_update_custom_property_request(
  base: Request(a),
  org: String,
  custom_property_name: String,
  data: b,
) -> Request(b)

pub fn orgs_create_or_update_custom_property_response(
  response: Response(BitArray),
) -> Result(Result(CustomProperty, String), DecodeError)

pub fn orgs_create_webhook_request(
  base: Request(a),
  org: String,
  data: b,
) -> Request(b)

pub fn orgs_create_webhook_response(
  response: Response(BitArray),
) -> Result(Result(OrgHook, String), DecodeError)

pub fn orgs_delete_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn orgs_delete_response(
  response: Response(BitArray),
) -> Result(Result(Dynamic, String), DecodeError)

pub fn orgs_delete_webhook_request(
  base: Request(a),
  org: String,
  hook_id: Int,
) -> Request(a)

pub fn orgs_delete_webhook_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_enable_or_disable_security_product_on_all_org_repos_request(
  base: Request(a),
  org: String,
  security_product: String,
  enablement: String,
  data: b,
) -> Request(b)

pub fn orgs_enable_or_disable_security_product_on_all_org_repos_response(
  response: Response(a),
) -> Result(Result(Nil, String), b)

pub fn orgs_get_all_custom_properties_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn orgs_get_all_custom_properties_response(
  response: Response(BitArray),
) -> Result(Result(List(CustomProperty), String), DecodeError)

pub fn orgs_get_custom_property_request(
  base: Request(a),
  org: String,
  custom_property_name: String,
) -> Request(a)

pub fn orgs_get_custom_property_response(
  response: Response(BitArray),
) -> Result(Result(CustomProperty, String), DecodeError)

pub fn orgs_get_membership_for_authenticated_user_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn orgs_get_membership_for_authenticated_user_response(
  response: Response(BitArray),
) -> Result(Result(OrgMembership, String), DecodeError)

pub fn orgs_get_membership_for_user_request(
  base: Request(a),
  org: String,
  username: String,
) -> Request(a)

pub fn orgs_get_membership_for_user_response(
  response: Response(BitArray),
) -> Result(Result(OrgMembership, String), DecodeError)

pub fn orgs_get_org_role_request(
  base: Request(a),
  org: String,
  role_id: Int,
) -> Request(a)

pub fn orgs_get_org_role_response(
  response: Response(BitArray),
) -> Result(Result(OrganizationRole, String), DecodeError)

pub fn orgs_get_request(
  base: Request(a),
  org: String,
) -> Request(a)

pub fn orgs_get_response(
  response: Response(BitArray),
) -> Result(Result(OrganizationFull, String), DecodeError)

pub fn orgs_get_webhook_config_for_org_request(
  base: Request(a),
  org: String,
  hook_id: Int,
) -> Request(a)

pub fn orgs_get_webhook_config_for_org_response(
  response: Response(BitArray),
) -> Result(Result(WebhookConfig, String), DecodeError)

pub fn orgs_get_webhook_delivery_request(
  base: Request(a),
  org: String,
  hook_id: Int,
  delivery_id: Int,
) -> Request(a)