pub struct BergClient(/* private fields */);
Implementations§
Methods from Deref<Target = Forgejo>§
Sourcepub async fn activitypub_repository(
&self,
repository_id: u32,
) -> Result<ActivityPub, ForgejoError>
pub async fn activitypub_repository( &self, repository_id: u32, ) -> Result<ActivityPub, ForgejoError>
Returns the Repository actor for a repo
repository-id
: repository ID of the repo
Sourcepub async fn activitypub_repository_inbox(
&self,
repository_id: u32,
body: ForgeLike,
) -> Result<(), ForgejoError>
pub async fn activitypub_repository_inbox( &self, repository_id: u32, body: ForgeLike, ) -> Result<(), ForgejoError>
Send to the inbox
repository-id
: repository ID of the repobody
: SeeForgeLike
Sourcepub async fn activitypub_person(
&self,
user_id: u32,
) -> Result<ActivityPub, ForgejoError>
pub async fn activitypub_person( &self, user_id: u32, ) -> Result<ActivityPub, ForgejoError>
Returns the Person actor for a user
user-id
: user ID of the user
Sourcepub async fn activitypub_person_inbox(
&self,
user_id: u32,
) -> Result<(), ForgejoError>
pub async fn activitypub_person_inbox( &self, user_id: u32, ) -> Result<(), ForgejoError>
Send to the inbox
user-id
: user ID of the user
Sourcepub async fn admin_cron_list(
&self,
query: AdminCronListQuery,
) -> Result<Vec<Cron>, ForgejoError>
pub async fn admin_cron_list( &self, query: AdminCronListQuery, ) -> Result<Vec<Cron>, ForgejoError>
List cron tasks
Sourcepub async fn admin_cron_run(&self, task: &str) -> Result<(), ForgejoError>
pub async fn admin_cron_run(&self, task: &str) -> Result<(), ForgejoError>
Run cron task
task
: task to run
Sourcepub async fn admin_get_all_emails(
&self,
query: AdminGetAllEmailsQuery,
) -> Result<Vec<Email>, ForgejoError>
pub async fn admin_get_all_emails( &self, query: AdminGetAllEmailsQuery, ) -> Result<Vec<Email>, ForgejoError>
List all emails
Sourcepub async fn admin_search_emails(
&self,
query: AdminSearchEmailsQuery,
) -> Result<Vec<Email>, ForgejoError>
pub async fn admin_search_emails( &self, query: AdminSearchEmailsQuery, ) -> Result<Vec<Email>, ForgejoError>
Search all emails
Sourcepub async fn admin_list_hooks(
&self,
query: AdminListHooksQuery,
) -> Result<Vec<Hook>, ForgejoError>
pub async fn admin_list_hooks( &self, query: AdminListHooksQuery, ) -> Result<Vec<Hook>, ForgejoError>
List system’s webhooks
Sourcepub async fn admin_create_hook(
&self,
body: CreateHookOption,
) -> Result<Hook, ForgejoError>
pub async fn admin_create_hook( &self, body: CreateHookOption, ) -> Result<Hook, ForgejoError>
Create a hook
body
: SeeCreateHookOption
Sourcepub async fn admin_get_hook(&self, id: u64) -> Result<Hook, ForgejoError>
pub async fn admin_get_hook(&self, id: u64) -> Result<Hook, ForgejoError>
Get a hook
id
: id of the hook to get
Sourcepub async fn admin_delete_hook(&self, id: u64) -> Result<(), ForgejoError>
pub async fn admin_delete_hook(&self, id: u64) -> Result<(), ForgejoError>
Delete a hook
id
: id of the hook to delete
Sourcepub async fn admin_edit_hook(
&self,
id: u64,
body: EditHookOption,
) -> Result<Hook, ForgejoError>
pub async fn admin_edit_hook( &self, id: u64, body: EditHookOption, ) -> Result<Hook, ForgejoError>
Update a hook
id
: id of the hook to updatebody
: SeeEditHookOption
Sourcepub async fn admin_get_all_orgs(
&self,
query: AdminGetAllOrgsQuery,
) -> Result<Vec<Organization>, ForgejoError>
pub async fn admin_get_all_orgs( &self, query: AdminGetAllOrgsQuery, ) -> Result<Vec<Organization>, ForgejoError>
List all organizations
Sourcepub async fn admin_get_runner_registration_token(
&self,
) -> Result<RegistrationTokenHeaders, ForgejoError>
pub async fn admin_get_runner_registration_token( &self, ) -> Result<RegistrationTokenHeaders, ForgejoError>
Get an global actions runner registration token
Sourcepub async fn admin_unadopted_list(
&self,
query: AdminUnadoptedListQuery,
) -> Result<Vec<String>, ForgejoError>
pub async fn admin_unadopted_list( &self, query: AdminUnadoptedListQuery, ) -> Result<Vec<String>, ForgejoError>
List unadopted repositories
Sourcepub async fn admin_adopt_repository(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn admin_adopt_repository( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Adopt unadopted files as a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn admin_delete_unadopted_repository(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn admin_delete_unadopted_repository( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Delete unadopted files
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn admin_search_users(
&self,
query: AdminSearchUsersQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn admin_search_users( &self, query: AdminSearchUsersQuery, ) -> Result<Vec<User>, ForgejoError>
Search users according filter conditions
Sourcepub async fn admin_create_user(
&self,
body: CreateUserOption,
) -> Result<User, ForgejoError>
pub async fn admin_create_user( &self, body: CreateUserOption, ) -> Result<User, ForgejoError>
Create a user
body
: SeeCreateUserOption
Sourcepub async fn admin_delete_user(
&self,
username: &str,
query: AdminDeleteUserQuery,
) -> Result<(), ForgejoError>
pub async fn admin_delete_user( &self, username: &str, query: AdminDeleteUserQuery, ) -> Result<(), ForgejoError>
Delete a user
username
: username of user to delete
Sourcepub async fn admin_edit_user(
&self,
username: &str,
body: EditUserOption,
) -> Result<User, ForgejoError>
pub async fn admin_edit_user( &self, username: &str, body: EditUserOption, ) -> Result<User, ForgejoError>
Edit an existing user
username
: username of user to editbody
: SeeEditUserOption
Sourcepub async fn admin_create_public_key(
&self,
username: &str,
key: CreateKeyOption,
) -> Result<PublicKey, ForgejoError>
pub async fn admin_create_public_key( &self, username: &str, key: CreateKeyOption, ) -> Result<PublicKey, ForgejoError>
Add a public key on behalf of a user
username
: username of the userkey
: SeeCreateKeyOption
Sourcepub async fn admin_delete_user_public_key(
&self,
username: &str,
id: u64,
) -> Result<(), ForgejoError>
pub async fn admin_delete_user_public_key( &self, username: &str, id: u64, ) -> Result<(), ForgejoError>
Delete a user’s public key
username
: username of userid
: id of the key to delete
Sourcepub async fn admin_create_org(
&self,
username: &str,
organization: CreateOrgOption,
) -> Result<Organization, ForgejoError>
pub async fn admin_create_org( &self, username: &str, organization: CreateOrgOption, ) -> Result<Organization, ForgejoError>
Create an organization
username
: username of the user that will own the created organizationorganization
: SeeCreateOrgOption
Sourcepub async fn admin_rename_user(
&self,
username: &str,
body: RenameUserOption,
) -> Result<(), ForgejoError>
pub async fn admin_rename_user( &self, username: &str, body: RenameUserOption, ) -> Result<(), ForgejoError>
Rename a user
username
: existing username of userbody
: SeeRenameUserOption
Sourcepub async fn admin_create_repo(
&self,
username: &str,
repository: CreateRepoOption,
) -> Result<Repository, ForgejoError>
pub async fn admin_create_repo( &self, username: &str, repository: CreateRepoOption, ) -> Result<Repository, ForgejoError>
Create a repository on behalf of a user
username
: username of the user. This user will own the created repositoryrepository
: SeeCreateRepoOption
Sourcepub async fn list_gitignores_templates(
&self,
) -> Result<Vec<String>, ForgejoError>
pub async fn list_gitignores_templates( &self, ) -> Result<Vec<String>, ForgejoError>
Returns a list of all gitignore templates
Sourcepub async fn get_gitignore_template_info(
&self,
name: &str,
) -> Result<GitignoreTemplateInfo, ForgejoError>
pub async fn get_gitignore_template_info( &self, name: &str, ) -> Result<GitignoreTemplateInfo, ForgejoError>
Returns information about a gitignore template
name
: name of the template
Sourcepub async fn list_label_templates(&self) -> Result<Vec<String>, ForgejoError>
pub async fn list_label_templates(&self) -> Result<Vec<String>, ForgejoError>
Returns a list of all label templates
Sourcepub async fn get_label_template_info(
&self,
name: &str,
) -> Result<Vec<LabelTemplate>, ForgejoError>
pub async fn get_label_template_info( &self, name: &str, ) -> Result<Vec<LabelTemplate>, ForgejoError>
Returns all labels in a template
name
: name of the template
Sourcepub async fn list_license_templates(
&self,
) -> Result<Vec<LicensesTemplateListEntry>, ForgejoError>
pub async fn list_license_templates( &self, ) -> Result<Vec<LicensesTemplateListEntry>, ForgejoError>
Returns a list of all license templates
Sourcepub async fn get_license_template_info(
&self,
name: &str,
) -> Result<LicenseTemplateInfo, ForgejoError>
pub async fn get_license_template_info( &self, name: &str, ) -> Result<LicenseTemplateInfo, ForgejoError>
Returns information about a license template
name
: name of the license
Sourcepub async fn render_markdown(
&self,
body: MarkdownOption,
) -> Result<String, ForgejoError>
pub async fn render_markdown( &self, body: MarkdownOption, ) -> Result<String, ForgejoError>
Render a markdown document as HTML
body
: SeeMarkdownOption
Sourcepub async fn render_markdown_raw(
&self,
body: String,
) -> Result<String, ForgejoError>
pub async fn render_markdown_raw( &self, body: String, ) -> Result<String, ForgejoError>
Render raw markdown as HTML
body
: Request body to render SeeString
Sourcepub async fn render_markup(
&self,
body: MarkupOption,
) -> Result<String, ForgejoError>
pub async fn render_markup( &self, body: MarkupOption, ) -> Result<String, ForgejoError>
Render a markup document as HTML
body
: SeeMarkupOption
Sourcepub async fn get_node_info(&self) -> Result<NodeInfo, ForgejoError>
pub async fn get_node_info(&self) -> Result<NodeInfo, ForgejoError>
Returns the nodeinfo of the Forgejo application
Sourcepub async fn notify_get_list(
&self,
query: NotifyGetListQuery,
) -> Result<Vec<NotificationThread>, ForgejoError>
pub async fn notify_get_list( &self, query: NotifyGetListQuery, ) -> Result<Vec<NotificationThread>, ForgejoError>
List users’s notification threads
Sourcepub async fn notify_read_list(
&self,
query: NotifyReadListQuery,
) -> Result<Vec<NotificationThread>, ForgejoError>
pub async fn notify_read_list( &self, query: NotifyReadListQuery, ) -> Result<Vec<NotificationThread>, ForgejoError>
Mark notification threads as read, pinned or unread
Sourcepub async fn notify_new_available(
&self,
) -> Result<NotificationCount, ForgejoError>
pub async fn notify_new_available( &self, ) -> Result<NotificationCount, ForgejoError>
Check if unread notifications exist
Sourcepub async fn notify_get_thread(
&self,
id: &str,
) -> Result<NotificationThread, ForgejoError>
pub async fn notify_get_thread( &self, id: &str, ) -> Result<NotificationThread, ForgejoError>
Get notification thread by ID
id
: id of notification thread
Sourcepub async fn notify_read_thread(
&self,
id: &str,
query: NotifyReadThreadQuery,
) -> Result<NotificationThread, ForgejoError>
pub async fn notify_read_thread( &self, id: &str, query: NotifyReadThreadQuery, ) -> Result<NotificationThread, ForgejoError>
Mark notification thread as read by ID
id
: id of notification thread
Sourcepub async fn create_org_repo_deprecated(
&self,
org: &str,
body: CreateRepoOption,
) -> Result<Repository, ForgejoError>
pub async fn create_org_repo_deprecated( &self, org: &str, body: CreateRepoOption, ) -> Result<Repository, ForgejoError>
Create a repository in an organization
org
: name of organizationbody
: SeeCreateRepoOption
Sourcepub async fn org_get_all(
&self,
query: OrgGetAllQuery,
) -> Result<Vec<Organization>, ForgejoError>
pub async fn org_get_all( &self, query: OrgGetAllQuery, ) -> Result<Vec<Organization>, ForgejoError>
Get list of organizations
Sourcepub async fn org_create(
&self,
organization: CreateOrgOption,
) -> Result<Organization, ForgejoError>
pub async fn org_create( &self, organization: CreateOrgOption, ) -> Result<Organization, ForgejoError>
Create an organization
organization
: SeeCreateOrgOption
Sourcepub async fn org_get(&self, org: &str) -> Result<Organization, ForgejoError>
pub async fn org_get(&self, org: &str) -> Result<Organization, ForgejoError>
Get an organization
org
: name of the organization to get
Sourcepub async fn org_delete(&self, org: &str) -> Result<(), ForgejoError>
pub async fn org_delete(&self, org: &str) -> Result<(), ForgejoError>
Delete an organization
org
: organization that is to be deleted
Sourcepub async fn org_edit(
&self,
org: &str,
body: EditOrgOption,
) -> Result<Organization, ForgejoError>
pub async fn org_edit( &self, org: &str, body: EditOrgOption, ) -> Result<Organization, ForgejoError>
Edit an organization
org
: name of the organization to editbody
: SeeEditOrgOption
Sourcepub async fn org_get_runner_registration_token(
&self,
org: &str,
) -> Result<RegistrationTokenHeaders, ForgejoError>
pub async fn org_get_runner_registration_token( &self, org: &str, ) -> Result<RegistrationTokenHeaders, ForgejoError>
Get an organization’s actions runner registration token
org
: name of the organization
Sourcepub async fn org_list_actions_secrets(
&self,
org: &str,
query: OrgListActionsSecretsQuery,
) -> Result<Vec<Secret>, ForgejoError>
pub async fn org_list_actions_secrets( &self, org: &str, query: OrgListActionsSecretsQuery, ) -> Result<Vec<Secret>, ForgejoError>
List an organization’s actions secrets
org
: name of the organization
Sourcepub async fn update_org_secret(
&self,
org: &str,
secretname: &str,
body: CreateOrUpdateSecretOption,
) -> Result<(), ForgejoError>
pub async fn update_org_secret( &self, org: &str, secretname: &str, body: CreateOrUpdateSecretOption, ) -> Result<(), ForgejoError>
Create or Update a secret value in an organization
org
: name of organizationsecretname
: name of the secretbody
: SeeCreateOrUpdateSecretOption
Sourcepub async fn delete_org_secret(
&self,
org: &str,
secretname: &str,
) -> Result<(), ForgejoError>
pub async fn delete_org_secret( &self, org: &str, secretname: &str, ) -> Result<(), ForgejoError>
Delete a secret in an organization
org
: name of organizationsecretname
: name of the secret
Sourcepub async fn get_org_variables_list(
&self,
org: &str,
query: GetOrgVariablesListQuery,
) -> Result<Vec<ActionVariable>, ForgejoError>
pub async fn get_org_variables_list( &self, org: &str, query: GetOrgVariablesListQuery, ) -> Result<Vec<ActionVariable>, ForgejoError>
Get an org-level variables list
org
: name of the organization
Sourcepub async fn get_org_variable(
&self,
org: &str,
variablename: &str,
) -> Result<ActionVariable, ForgejoError>
pub async fn get_org_variable( &self, org: &str, variablename: &str, ) -> Result<ActionVariable, ForgejoError>
Get an org-level variable
org
: name of the organizationvariablename
: name of the variable
Sourcepub async fn update_org_variable(
&self,
org: &str,
variablename: &str,
body: UpdateVariableOption,
) -> Result<(), ForgejoError>
pub async fn update_org_variable( &self, org: &str, variablename: &str, body: UpdateVariableOption, ) -> Result<(), ForgejoError>
Update an org-level variable
org
: name of the organizationvariablename
: name of the variablebody
: SeeUpdateVariableOption
Sourcepub async fn create_org_variable(
&self,
org: &str,
variablename: &str,
body: CreateVariableOption,
) -> Result<(), ForgejoError>
pub async fn create_org_variable( &self, org: &str, variablename: &str, body: CreateVariableOption, ) -> Result<(), ForgejoError>
Create an org-level variable
org
: name of the organizationvariablename
: name of the variablebody
: SeeCreateVariableOption
Sourcepub async fn delete_org_variable(
&self,
org: &str,
variablename: &str,
) -> Result<Option<ActionVariable>, ForgejoError>
pub async fn delete_org_variable( &self, org: &str, variablename: &str, ) -> Result<Option<ActionVariable>, ForgejoError>
Delete an org-level variable
org
: name of the organizationvariablename
: name of the variable
Sourcepub async fn org_list_activity_feeds(
&self,
org: &str,
query: OrgListActivityFeedsQuery,
) -> Result<Vec<Activity>, ForgejoError>
pub async fn org_list_activity_feeds( &self, org: &str, query: OrgListActivityFeedsQuery, ) -> Result<Vec<Activity>, ForgejoError>
List an organization’s activity feeds
org
: name of the org
Sourcepub async fn org_update_avatar(
&self,
org: &str,
body: UpdateUserAvatarOption,
) -> Result<(), ForgejoError>
pub async fn org_update_avatar( &self, org: &str, body: UpdateUserAvatarOption, ) -> Result<(), ForgejoError>
Update Avatar
org
: name of the organizationbody
: SeeUpdateUserAvatarOption
Sourcepub async fn org_delete_avatar(&self, org: &str) -> Result<(), ForgejoError>
pub async fn org_delete_avatar(&self, org: &str) -> Result<(), ForgejoError>
Delete Avatar
org
: name of the organization
Sourcepub async fn org_block_user(
&self,
org: &str,
username: &str,
) -> Result<(), ForgejoError>
pub async fn org_block_user( &self, org: &str, username: &str, ) -> Result<(), ForgejoError>
Blocks a user from the organization
org
: name of the orgusername
: username of the user
Sourcepub async fn org_list_hooks(
&self,
org: &str,
query: OrgListHooksQuery,
) -> Result<Vec<Hook>, ForgejoError>
pub async fn org_list_hooks( &self, org: &str, query: OrgListHooksQuery, ) -> Result<Vec<Hook>, ForgejoError>
List an organization’s webhooks
org
: name of the organization
Sourcepub async fn org_create_hook(
&self,
org: &str,
body: CreateHookOption,
) -> Result<Hook, ForgejoError>
pub async fn org_create_hook( &self, org: &str, body: CreateHookOption, ) -> Result<Hook, ForgejoError>
Create a hook
org
: name of the organizationbody
: SeeCreateHookOption
Sourcepub async fn org_get_hook(
&self,
org: &str,
id: u64,
) -> Result<Hook, ForgejoError>
pub async fn org_get_hook( &self, org: &str, id: u64, ) -> Result<Hook, ForgejoError>
Get a hook
org
: name of the organizationid
: id of the hook to get
Sourcepub async fn org_delete_hook(
&self,
org: &str,
id: u64,
) -> Result<(), ForgejoError>
pub async fn org_delete_hook( &self, org: &str, id: u64, ) -> Result<(), ForgejoError>
Delete a hook
org
: name of the organizationid
: id of the hook to delete
Sourcepub async fn org_edit_hook(
&self,
org: &str,
id: u64,
body: EditHookOption,
) -> Result<Hook, ForgejoError>
pub async fn org_edit_hook( &self, org: &str, id: u64, body: EditHookOption, ) -> Result<Hook, ForgejoError>
Update a hook
org
: name of the organizationid
: id of the hook to updatebody
: SeeEditHookOption
Sourcepub async fn org_list_labels(
&self,
org: &str,
query: OrgListLabelsQuery,
) -> Result<Vec<Label>, ForgejoError>
pub async fn org_list_labels( &self, org: &str, query: OrgListLabelsQuery, ) -> Result<Vec<Label>, ForgejoError>
List an organization’s labels
org
: name of the organization
Sourcepub async fn org_create_label(
&self,
org: &str,
body: CreateLabelOption,
) -> Result<Label, ForgejoError>
pub async fn org_create_label( &self, org: &str, body: CreateLabelOption, ) -> Result<Label, ForgejoError>
Create a label for an organization
org
: name of the organizationbody
: SeeCreateLabelOption
Sourcepub async fn org_get_label(
&self,
org: &str,
id: u64,
) -> Result<Label, ForgejoError>
pub async fn org_get_label( &self, org: &str, id: u64, ) -> Result<Label, ForgejoError>
Get a single label
org
: name of the organizationid
: id of the label to get
Sourcepub async fn org_delete_label(
&self,
org: &str,
id: u64,
) -> Result<(), ForgejoError>
pub async fn org_delete_label( &self, org: &str, id: u64, ) -> Result<(), ForgejoError>
Delete a label
org
: name of the organizationid
: id of the label to delete
Sourcepub async fn org_edit_label(
&self,
org: &str,
id: u64,
body: EditLabelOption,
) -> Result<Label, ForgejoError>
pub async fn org_edit_label( &self, org: &str, id: u64, body: EditLabelOption, ) -> Result<Label, ForgejoError>
Update a label
org
: name of the organizationid
: id of the label to editbody
: SeeEditLabelOption
Sourcepub async fn org_list_blocked_users(
&self,
org: &str,
query: OrgListBlockedUsersQuery,
) -> Result<Vec<BlockedUser>, ForgejoError>
pub async fn org_list_blocked_users( &self, org: &str, query: OrgListBlockedUsersQuery, ) -> Result<Vec<BlockedUser>, ForgejoError>
List the organization’s blocked users
org
: name of the org
Sourcepub async fn org_list_members(
&self,
org: &str,
query: OrgListMembersQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn org_list_members( &self, org: &str, query: OrgListMembersQuery, ) -> Result<Vec<User>, ForgejoError>
List an organization’s members
org
: name of the organization
Sourcepub async fn org_is_member(
&self,
org: &str,
username: &str,
) -> Result<(), ForgejoError>
pub async fn org_is_member( &self, org: &str, username: &str, ) -> Result<(), ForgejoError>
Check if a user is a member of an organization
org
: name of the organizationusername
: username of the user
Sourcepub async fn org_delete_member(
&self,
org: &str,
username: &str,
) -> Result<(), ForgejoError>
pub async fn org_delete_member( &self, org: &str, username: &str, ) -> Result<(), ForgejoError>
Remove a member from an organization
org
: name of the organizationusername
: username of the user
Sourcepub async fn org_list_public_members(
&self,
org: &str,
query: OrgListPublicMembersQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn org_list_public_members( &self, org: &str, query: OrgListPublicMembersQuery, ) -> Result<Vec<User>, ForgejoError>
List an organization’s public members
org
: name of the organization
Sourcepub async fn org_is_public_member(
&self,
org: &str,
username: &str,
) -> Result<(), ForgejoError>
pub async fn org_is_public_member( &self, org: &str, username: &str, ) -> Result<(), ForgejoError>
Check if a user is a public member of an organization
org
: name of the organizationusername
: username of the user
Sourcepub async fn org_publicize_member(
&self,
org: &str,
username: &str,
) -> Result<(), ForgejoError>
pub async fn org_publicize_member( &self, org: &str, username: &str, ) -> Result<(), ForgejoError>
Publicize a user’s membership
org
: name of the organizationusername
: username of the user
Sourcepub async fn org_conceal_member(
&self,
org: &str,
username: &str,
) -> Result<(), ForgejoError>
pub async fn org_conceal_member( &self, org: &str, username: &str, ) -> Result<(), ForgejoError>
Conceal a user’s membership
org
: name of the organizationusername
: username of the user
Sourcepub async fn org_list_repos(
&self,
org: &str,
query: OrgListReposQuery,
) -> Result<Vec<Repository>, ForgejoError>
pub async fn org_list_repos( &self, org: &str, query: OrgListReposQuery, ) -> Result<Vec<Repository>, ForgejoError>
List an organization’s repos
org
: name of the organization
Sourcepub async fn create_org_repo(
&self,
org: &str,
body: CreateRepoOption,
) -> Result<Repository, ForgejoError>
pub async fn create_org_repo( &self, org: &str, body: CreateRepoOption, ) -> Result<Repository, ForgejoError>
Create a repository in an organization
org
: name of organizationbody
: SeeCreateRepoOption
Sourcepub async fn org_list_teams(
&self,
org: &str,
query: OrgListTeamsQuery,
) -> Result<Vec<Team>, ForgejoError>
pub async fn org_list_teams( &self, org: &str, query: OrgListTeamsQuery, ) -> Result<Vec<Team>, ForgejoError>
List an organization’s teams
org
: name of the organization
Sourcepub async fn org_create_team(
&self,
org: &str,
body: CreateTeamOption,
) -> Result<Team, ForgejoError>
pub async fn org_create_team( &self, org: &str, body: CreateTeamOption, ) -> Result<Team, ForgejoError>
Create a team
org
: name of the organizationbody
: SeeCreateTeamOption
Sourcepub async fn team_search(
&self,
org: &str,
query: TeamSearchQuery,
) -> Result<TeamSearchResponse, ForgejoError>
pub async fn team_search( &self, org: &str, query: TeamSearchQuery, ) -> Result<TeamSearchResponse, ForgejoError>
Search for teams within an organization
org
: name of the organization
Sourcepub async fn org_unblock_user(
&self,
org: &str,
username: &str,
) -> Result<(), ForgejoError>
pub async fn org_unblock_user( &self, org: &str, username: &str, ) -> Result<(), ForgejoError>
Unblock a user from the organization
org
: name of the orgusername
: username of the user
Sourcepub async fn list_packages(
&self,
owner: &str,
query: ListPackagesQuery,
) -> Result<Vec<Package>, ForgejoError>
pub async fn list_packages( &self, owner: &str, query: ListPackagesQuery, ) -> Result<Vec<Package>, ForgejoError>
Gets all packages of an owner
owner
: owner of the packages
Sourcepub async fn get_package(
&self,
owner: &str,
type: &str,
name: &str,
version: &str,
) -> Result<Package, ForgejoError>
pub async fn get_package( &self, owner: &str, type: &str, name: &str, version: &str, ) -> Result<Package, ForgejoError>
Gets a package
owner
: owner of the packagetype
: type of the packagename
: name of the packageversion
: version of the package
Sourcepub async fn delete_package(
&self,
owner: &str,
type: &str,
name: &str,
version: &str,
) -> Result<(), ForgejoError>
pub async fn delete_package( &self, owner: &str, type: &str, name: &str, version: &str, ) -> Result<(), ForgejoError>
Delete a package
owner
: owner of the packagetype
: type of the packagename
: name of the packageversion
: version of the package
Sourcepub async fn list_package_files(
&self,
owner: &str,
type: &str,
name: &str,
version: &str,
) -> Result<Vec<PackageFile>, ForgejoError>
pub async fn list_package_files( &self, owner: &str, type: &str, name: &str, version: &str, ) -> Result<Vec<PackageFile>, ForgejoError>
Gets all files of a package
owner
: owner of the packagetype
: type of the packagename
: name of the packageversion
: version of the package
Sourcepub async fn issue_search_issues(
&self,
query: IssueSearchIssuesQuery,
) -> Result<Vec<Issue>, ForgejoError>
pub async fn issue_search_issues( &self, query: IssueSearchIssuesQuery, ) -> Result<Vec<Issue>, ForgejoError>
Search for issues across the repositories that the user has access to
Sourcepub async fn repo_migrate(
&self,
body: MigrateRepoOptions,
) -> Result<Repository, ForgejoError>
pub async fn repo_migrate( &self, body: MigrateRepoOptions, ) -> Result<Repository, ForgejoError>
Migrate a remote git repository
body
: SeeMigrateRepoOptions
Sourcepub async fn repo_search(
&self,
query: RepoSearchQuery,
) -> Result<SearchResults, ForgejoError>
pub async fn repo_search( &self, query: RepoSearchQuery, ) -> Result<SearchResults, ForgejoError>
Search for repositories
Sourcepub async fn repo_get(
&self,
owner: &str,
repo: &str,
) -> Result<Repository, ForgejoError>
pub async fn repo_get( &self, owner: &str, repo: &str, ) -> Result<Repository, ForgejoError>
Get a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_delete(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Delete a repository
owner
: owner of the repo to deleterepo
: name of the repo to delete
Sourcepub async fn repo_edit(
&self,
owner: &str,
repo: &str,
body: EditRepoOption,
) -> Result<Repository, ForgejoError>
pub async fn repo_edit( &self, owner: &str, repo: &str, body: EditRepoOption, ) -> Result<Repository, ForgejoError>
Edit a repository’s properties. Only fields that are set will be changed.
owner
: owner of the repo to editrepo
: name of the repo to editbody
: Properties of a repo that you can edit SeeEditRepoOption
Sourcepub async fn repo_list_actions_secrets(
&self,
owner: &str,
repo: &str,
query: RepoListActionsSecretsQuery,
) -> Result<Vec<Secret>, ForgejoError>
pub async fn repo_list_actions_secrets( &self, owner: &str, repo: &str, query: RepoListActionsSecretsQuery, ) -> Result<Vec<Secret>, ForgejoError>
List an repo’s actions secrets
owner
: owner of the repositoryrepo
: name of the repository
Sourcepub async fn update_repo_secret(
&self,
owner: &str,
repo: &str,
secretname: &str,
body: CreateOrUpdateSecretOption,
) -> Result<(), ForgejoError>
pub async fn update_repo_secret( &self, owner: &str, repo: &str, secretname: &str, body: CreateOrUpdateSecretOption, ) -> Result<(), ForgejoError>
Create or Update a secret value in a repository
owner
: owner of the repositoryrepo
: name of the repositorysecretname
: name of the secretbody
: SeeCreateOrUpdateSecretOption
Sourcepub async fn delete_repo_secret(
&self,
owner: &str,
repo: &str,
secretname: &str,
) -> Result<(), ForgejoError>
pub async fn delete_repo_secret( &self, owner: &str, repo: &str, secretname: &str, ) -> Result<(), ForgejoError>
Delete a secret in a repository
owner
: owner of the repositoryrepo
: name of the repositorysecretname
: name of the secret
Sourcepub async fn list_action_tasks(
&self,
owner: &str,
repo: &str,
query: ListActionTasksQuery,
) -> Result<ActionTaskResponse, ForgejoError>
pub async fn list_action_tasks( &self, owner: &str, repo: &str, query: ListActionTasksQuery, ) -> Result<ActionTaskResponse, ForgejoError>
List a repository’s action tasks
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn get_repo_variables_list(
&self,
owner: &str,
repo: &str,
query: GetRepoVariablesListQuery,
) -> Result<Vec<ActionVariable>, ForgejoError>
pub async fn get_repo_variables_list( &self, owner: &str, repo: &str, query: GetRepoVariablesListQuery, ) -> Result<Vec<ActionVariable>, ForgejoError>
Get repo-level variables list
owner
: name of the ownerrepo
: name of the repository
Sourcepub async fn get_repo_variable(
&self,
owner: &str,
repo: &str,
variablename: &str,
) -> Result<ActionVariable, ForgejoError>
pub async fn get_repo_variable( &self, owner: &str, repo: &str, variablename: &str, ) -> Result<ActionVariable, ForgejoError>
Get a repo-level variable
owner
: name of the ownerrepo
: name of the repositoryvariablename
: name of the variable
Sourcepub async fn update_repo_variable(
&self,
owner: &str,
repo: &str,
variablename: &str,
body: UpdateVariableOption,
) -> Result<(), ForgejoError>
pub async fn update_repo_variable( &self, owner: &str, repo: &str, variablename: &str, body: UpdateVariableOption, ) -> Result<(), ForgejoError>
Update a repo-level variable
owner
: name of the ownerrepo
: name of the repositoryvariablename
: name of the variablebody
: SeeUpdateVariableOption
Sourcepub async fn create_repo_variable(
&self,
owner: &str,
repo: &str,
variablename: &str,
body: CreateVariableOption,
) -> Result<(), ForgejoError>
pub async fn create_repo_variable( &self, owner: &str, repo: &str, variablename: &str, body: CreateVariableOption, ) -> Result<(), ForgejoError>
Create a repo-level variable
owner
: name of the ownerrepo
: name of the repositoryvariablename
: name of the variablebody
: SeeCreateVariableOption
Sourcepub async fn delete_repo_variable(
&self,
owner: &str,
repo: &str,
variablename: &str,
) -> Result<Option<ActionVariable>, ForgejoError>
pub async fn delete_repo_variable( &self, owner: &str, repo: &str, variablename: &str, ) -> Result<Option<ActionVariable>, ForgejoError>
Delete a repo-level variable
owner
: name of the ownerrepo
: name of the repositoryvariablename
: name of the variable
Sourcepub async fn dispatch_workflow(
&self,
owner: &str,
repo: &str,
workflowname: &str,
body: DispatchWorkflowOption,
) -> Result<(), ForgejoError>
pub async fn dispatch_workflow( &self, owner: &str, repo: &str, workflowname: &str, body: DispatchWorkflowOption, ) -> Result<(), ForgejoError>
Dispatches a workflow
owner
: owner of the reporepo
: name of the repoworkflowname
: name of the workflowbody
: SeeDispatchWorkflowOption
Sourcepub async fn repo_list_activity_feeds(
&self,
owner: &str,
repo: &str,
query: RepoListActivityFeedsQuery,
) -> Result<Vec<Activity>, ForgejoError>
pub async fn repo_list_activity_feeds( &self, owner: &str, repo: &str, query: RepoListActivityFeedsQuery, ) -> Result<Vec<Activity>, ForgejoError>
List a repository’s activity feeds
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_get_archive(
&self,
owner: &str,
repo: &str,
archive: &str,
) -> Result<Vec<u8>, ForgejoError>
pub async fn repo_get_archive( &self, owner: &str, repo: &str, archive: &str, ) -> Result<Vec<u8>, ForgejoError>
Get an archive of a repository
owner
: owner of the reporepo
: name of the repoarchive
: the git reference for download with attached archive format (e.g. master.zip)
Sourcepub async fn repo_get_assignees(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<User>, ForgejoError>
pub async fn repo_get_assignees( &self, owner: &str, repo: &str, ) -> Result<Vec<User>, ForgejoError>
Return all users that have write access and can be assigned to issues
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_update_avatar(
&self,
owner: &str,
repo: &str,
body: UpdateRepoAvatarOption,
) -> Result<(), ForgejoError>
pub async fn repo_update_avatar( &self, owner: &str, repo: &str, body: UpdateRepoAvatarOption, ) -> Result<(), ForgejoError>
Update avatar
owner
: owner of the reporepo
: name of the repobody
: SeeUpdateRepoAvatarOption
Sourcepub async fn repo_delete_avatar(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_avatar( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Delete avatar
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_list_branch_protection(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<BranchProtection>, ForgejoError>
pub async fn repo_list_branch_protection( &self, owner: &str, repo: &str, ) -> Result<Vec<BranchProtection>, ForgejoError>
List branch protections for a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_create_branch_protection(
&self,
owner: &str,
repo: &str,
body: CreateBranchProtectionOption,
) -> Result<BranchProtection, ForgejoError>
pub async fn repo_create_branch_protection( &self, owner: &str, repo: &str, body: CreateBranchProtectionOption, ) -> Result<BranchProtection, ForgejoError>
Create a branch protections for a repository
owner
: owner of the reporepo
: name of the repobody
: SeeCreateBranchProtectionOption
Sourcepub async fn repo_get_branch_protection(
&self,
owner: &str,
repo: &str,
name: &str,
) -> Result<BranchProtection, ForgejoError>
pub async fn repo_get_branch_protection( &self, owner: &str, repo: &str, name: &str, ) -> Result<BranchProtection, ForgejoError>
Get a specific branch protection for the repository
owner
: owner of the reporepo
: name of the reponame
: name of protected branch
Sourcepub async fn repo_delete_branch_protection(
&self,
owner: &str,
repo: &str,
name: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_branch_protection( &self, owner: &str, repo: &str, name: &str, ) -> Result<(), ForgejoError>
Delete a specific branch protection for the repository
owner
: owner of the reporepo
: name of the reponame
: name of protected branch
Sourcepub async fn repo_edit_branch_protection(
&self,
owner: &str,
repo: &str,
name: &str,
body: EditBranchProtectionOption,
) -> Result<BranchProtection, ForgejoError>
pub async fn repo_edit_branch_protection( &self, owner: &str, repo: &str, name: &str, body: EditBranchProtectionOption, ) -> Result<BranchProtection, ForgejoError>
Edit a branch protections for a repository. Only fields that are set will be changed
owner
: owner of the reporepo
: name of the reponame
: name of protected branchbody
: SeeEditBranchProtectionOption
Sourcepub async fn repo_list_branches(
&self,
owner: &str,
repo: &str,
query: RepoListBranchesQuery,
) -> Result<Vec<Branch>, ForgejoError>
pub async fn repo_list_branches( &self, owner: &str, repo: &str, query: RepoListBranchesQuery, ) -> Result<Vec<Branch>, ForgejoError>
List a repository’s branches
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_create_branch(
&self,
owner: &str,
repo: &str,
body: CreateBranchRepoOption,
) -> Result<Branch, ForgejoError>
pub async fn repo_create_branch( &self, owner: &str, repo: &str, body: CreateBranchRepoOption, ) -> Result<Branch, ForgejoError>
Create a branch
owner
: owner of the reporepo
: name of the repobody
: SeeCreateBranchRepoOption
Sourcepub async fn repo_get_branch(
&self,
owner: &str,
repo: &str,
branch: &str,
) -> Result<Branch, ForgejoError>
pub async fn repo_get_branch( &self, owner: &str, repo: &str, branch: &str, ) -> Result<Branch, ForgejoError>
Retrieve a specific branch from a repository, including its effective branch protection
owner
: owner of the reporepo
: name of the repobranch
: branch to get
Sourcepub async fn repo_delete_branch(
&self,
owner: &str,
repo: &str,
branch: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_branch( &self, owner: &str, repo: &str, branch: &str, ) -> Result<(), ForgejoError>
Delete a specific branch from a repository
owner
: owner of the reporepo
: name of the repobranch
: branch to delete
Sourcepub async fn repo_list_collaborators(
&self,
owner: &str,
repo: &str,
query: RepoListCollaboratorsQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn repo_list_collaborators( &self, owner: &str, repo: &str, query: RepoListCollaboratorsQuery, ) -> Result<Vec<User>, ForgejoError>
List a repository’s collaborators
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_check_collaborator(
&self,
owner: &str,
repo: &str,
collaborator: &str,
) -> Result<(), ForgejoError>
pub async fn repo_check_collaborator( &self, owner: &str, repo: &str, collaborator: &str, ) -> Result<(), ForgejoError>
Check if a user is a collaborator of a repository
owner
: owner of the reporepo
: name of the repocollaborator
: username of the collaborator
Sourcepub async fn repo_add_collaborator(
&self,
owner: &str,
repo: &str,
collaborator: &str,
body: AddCollaboratorOption,
) -> Result<(), ForgejoError>
pub async fn repo_add_collaborator( &self, owner: &str, repo: &str, collaborator: &str, body: AddCollaboratorOption, ) -> Result<(), ForgejoError>
Add a collaborator to a repository
owner
: owner of the reporepo
: name of the repocollaborator
: username of the collaborator to addbody
: SeeAddCollaboratorOption
Sourcepub async fn repo_delete_collaborator(
&self,
owner: &str,
repo: &str,
collaborator: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_collaborator( &self, owner: &str, repo: &str, collaborator: &str, ) -> Result<(), ForgejoError>
Delete a collaborator from a repository
owner
: owner of the reporepo
: name of the repocollaborator
: username of the collaborator to delete
Sourcepub async fn repo_get_repo_permissions(
&self,
owner: &str,
repo: &str,
collaborator: &str,
) -> Result<RepoCollaboratorPermission, ForgejoError>
pub async fn repo_get_repo_permissions( &self, owner: &str, repo: &str, collaborator: &str, ) -> Result<RepoCollaboratorPermission, ForgejoError>
Get repository permissions for a user
owner
: owner of the reporepo
: name of the repocollaborator
: username of the collaborator
Sourcepub async fn repo_get_all_commits(
&self,
owner: &str,
repo: &str,
query: RepoGetAllCommitsQuery,
) -> Result<(CommitListHeaders, Vec<Commit>), ForgejoError>
pub async fn repo_get_all_commits( &self, owner: &str, repo: &str, query: RepoGetAllCommitsQuery, ) -> Result<(CommitListHeaders, Vec<Commit>), ForgejoError>
Get a list of all commits from a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_get_combined_status_by_ref(
&self,
owner: &str,
repo: &str,
ref: &str,
query: RepoGetCombinedStatusByRefQuery,
) -> Result<CombinedStatus, ForgejoError>
pub async fn repo_get_combined_status_by_ref( &self, owner: &str, repo: &str, ref: &str, query: RepoGetCombinedStatusByRefQuery, ) -> Result<CombinedStatus, ForgejoError>
Get a commit’s combined status, by branch/tag/commit reference
owner
: owner of the reporepo
: name of the reporef
: name of branch/tag/commit
Sourcepub async fn repo_list_statuses_by_ref(
&self,
owner: &str,
repo: &str,
ref: &str,
query: RepoListStatusesByRefQuery,
) -> Result<Vec<CommitStatus>, ForgejoError>
pub async fn repo_list_statuses_by_ref( &self, owner: &str, repo: &str, ref: &str, query: RepoListStatusesByRefQuery, ) -> Result<Vec<CommitStatus>, ForgejoError>
Get a commit’s statuses, by branch/tag/commit reference
owner
: owner of the reporepo
: name of the reporef
: name of branch/tag/commit
Sourcepub async fn repo_get_commit_pull_request(
&self,
owner: &str,
repo: &str,
sha: &str,
) -> Result<PullRequest, ForgejoError>
pub async fn repo_get_commit_pull_request( &self, owner: &str, repo: &str, sha: &str, ) -> Result<PullRequest, ForgejoError>
Get the pull request of the commit
owner
: owner of the reporepo
: name of the reposha
: SHA of the commit to get
Sourcepub async fn repo_compare_diff(
&self,
owner: &str,
repo: &str,
basehead: &str,
) -> Result<Compare, ForgejoError>
pub async fn repo_compare_diff( &self, owner: &str, repo: &str, basehead: &str, ) -> Result<Compare, ForgejoError>
Get commit comparison information
owner
: owner of the reporepo
: name of the repobasehead
: compare two branches or commits
Sourcepub async fn repo_get_contents_list(
&self,
owner: &str,
repo: &str,
query: RepoGetContentsListQuery,
) -> Result<Vec<ContentsResponse>, ForgejoError>
pub async fn repo_get_contents_list( &self, owner: &str, repo: &str, query: RepoGetContentsListQuery, ) -> Result<Vec<ContentsResponse>, ForgejoError>
Gets the metadata of all the entries of the root dir
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_change_files(
&self,
owner: &str,
repo: &str,
body: ChangeFilesOptions,
) -> Result<FilesResponse, ForgejoError>
pub async fn repo_change_files( &self, owner: &str, repo: &str, body: ChangeFilesOptions, ) -> Result<FilesResponse, ForgejoError>
Modify multiple files in a repository
owner
: owner of the reporepo
: name of the repobody
: SeeChangeFilesOptions
Sourcepub async fn repo_get_contents(
&self,
owner: &str,
repo: &str,
filepath: &str,
query: RepoGetContentsQuery,
) -> Result<ContentsResponse, ForgejoError>
pub async fn repo_get_contents( &self, owner: &str, repo: &str, filepath: &str, query: RepoGetContentsQuery, ) -> Result<ContentsResponse, ForgejoError>
Gets the metadata and contents (if a file) of an entry in a repository, or a list of entries if a dir
owner
: owner of the reporepo
: name of the repofilepath
: path of the dir, file, symlink or submodule in the repo
Sourcepub async fn repo_update_file(
&self,
owner: &str,
repo: &str,
filepath: &str,
body: UpdateFileOptions,
) -> Result<FileResponse, ForgejoError>
pub async fn repo_update_file( &self, owner: &str, repo: &str, filepath: &str, body: UpdateFileOptions, ) -> Result<FileResponse, ForgejoError>
Update a file in a repository
owner
: owner of the reporepo
: name of the repofilepath
: path of the file to updatebody
: SeeUpdateFileOptions
Sourcepub async fn repo_create_file(
&self,
owner: &str,
repo: &str,
filepath: &str,
body: CreateFileOptions,
) -> Result<FileResponse, ForgejoError>
pub async fn repo_create_file( &self, owner: &str, repo: &str, filepath: &str, body: CreateFileOptions, ) -> Result<FileResponse, ForgejoError>
Create a file in a repository
owner
: owner of the reporepo
: name of the repofilepath
: path of the file to createbody
: SeeCreateFileOptions
Sourcepub async fn repo_delete_file(
&self,
owner: &str,
repo: &str,
filepath: &str,
body: DeleteFileOptions,
) -> Result<FileDeleteResponse, ForgejoError>
pub async fn repo_delete_file( &self, owner: &str, repo: &str, filepath: &str, body: DeleteFileOptions, ) -> Result<FileDeleteResponse, ForgejoError>
Delete a file in a repository
owner
: owner of the reporepo
: name of the repofilepath
: path of the file to deletebody
: SeeDeleteFileOptions
Sourcepub async fn repo_apply_diff_patch(
&self,
owner: &str,
repo: &str,
body: UpdateFileOptions,
) -> Result<FileResponse, ForgejoError>
pub async fn repo_apply_diff_patch( &self, owner: &str, repo: &str, body: UpdateFileOptions, ) -> Result<FileResponse, ForgejoError>
Apply diff patch to repository
owner
: owner of the reporepo
: name of the repobody
: SeeUpdateFileOptions
Sourcepub async fn repo_get_editor_config(
&self,
owner: &str,
repo: &str,
filepath: &str,
query: RepoGetEditorConfigQuery,
) -> Result<(), ForgejoError>
pub async fn repo_get_editor_config( &self, owner: &str, repo: &str, filepath: &str, query: RepoGetEditorConfigQuery, ) -> Result<(), ForgejoError>
Get the EditorConfig definitions of a file in a repository
owner
: owner of the reporepo
: name of the repofilepath
: filepath of file to get
Sourcepub async fn repo_list_flags(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<String>, ForgejoError>
pub async fn repo_list_flags( &self, owner: &str, repo: &str, ) -> Result<Vec<String>, ForgejoError>
List a repository’s flags
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_replace_all_flags(
&self,
owner: &str,
repo: &str,
body: ReplaceFlagsOption,
) -> Result<(), ForgejoError>
pub async fn repo_replace_all_flags( &self, owner: &str, repo: &str, body: ReplaceFlagsOption, ) -> Result<(), ForgejoError>
Replace all flags of a repository
owner
: owner of the reporepo
: name of the repobody
: SeeReplaceFlagsOption
Sourcepub async fn repo_delete_all_flags(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_all_flags( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Remove all flags from a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_check_flag(
&self,
owner: &str,
repo: &str,
flag: &str,
) -> Result<(), ForgejoError>
pub async fn repo_check_flag( &self, owner: &str, repo: &str, flag: &str, ) -> Result<(), ForgejoError>
Check if a repository has a given flag
owner
: owner of the reporepo
: name of the repoflag
: name of the flag
Sourcepub async fn repo_add_flag(
&self,
owner: &str,
repo: &str,
flag: &str,
) -> Result<(), ForgejoError>
pub async fn repo_add_flag( &self, owner: &str, repo: &str, flag: &str, ) -> Result<(), ForgejoError>
Add a flag to a repository
owner
: owner of the reporepo
: name of the repoflag
: name of the flag
Sourcepub async fn repo_delete_flag(
&self,
owner: &str,
repo: &str,
flag: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_flag( &self, owner: &str, repo: &str, flag: &str, ) -> Result<(), ForgejoError>
Remove a flag from a repository
owner
: owner of the reporepo
: name of the repoflag
: name of the flag
Sourcepub async fn list_forks(
&self,
owner: &str,
repo: &str,
query: ListForksQuery,
) -> Result<Vec<Repository>, ForgejoError>
pub async fn list_forks( &self, owner: &str, repo: &str, query: ListForksQuery, ) -> Result<Vec<Repository>, ForgejoError>
List a repository’s forks
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn create_fork(
&self,
owner: &str,
repo: &str,
body: CreateForkOption,
) -> Result<Repository, ForgejoError>
pub async fn create_fork( &self, owner: &str, repo: &str, body: CreateForkOption, ) -> Result<Repository, ForgejoError>
Fork a repository
owner
: owner of the repo to forkrepo
: name of the repo to forkbody
: SeeCreateForkOption
Sourcepub async fn get_blob(
&self,
owner: &str,
repo: &str,
sha: &str,
) -> Result<GitBlobResponse, ForgejoError>
pub async fn get_blob( &self, owner: &str, repo: &str, sha: &str, ) -> Result<GitBlobResponse, ForgejoError>
Gets the blob of a repository.
owner
: owner of the reporepo
: name of the reposha
: sha of the commit
Sourcepub async fn repo_get_single_commit(
&self,
owner: &str,
repo: &str,
sha: &str,
query: RepoGetSingleCommitQuery,
) -> Result<Commit, ForgejoError>
pub async fn repo_get_single_commit( &self, owner: &str, repo: &str, sha: &str, query: RepoGetSingleCommitQuery, ) -> Result<Commit, ForgejoError>
Get a single commit from a repository
owner
: owner of the reporepo
: name of the reposha
: a git ref or commit sha
Sourcepub async fn repo_download_commit_diff_or_patch(
&self,
owner: &str,
repo: &str,
sha: &str,
diff_type: &str,
) -> Result<String, ForgejoError>
pub async fn repo_download_commit_diff_or_patch( &self, owner: &str, repo: &str, sha: &str, diff_type: &str, ) -> Result<String, ForgejoError>
Get a commit’s diff or patch
owner
: owner of the reporepo
: name of the reposha
: SHA of the commit to getdiffType
: whether the output is diff or patch
Sourcepub async fn repo_get_note(
&self,
owner: &str,
repo: &str,
sha: &str,
query: RepoGetNoteQuery,
) -> Result<Note, ForgejoError>
pub async fn repo_get_note( &self, owner: &str, repo: &str, sha: &str, query: RepoGetNoteQuery, ) -> Result<Note, ForgejoError>
Get a note corresponding to a single commit from a repository
owner
: owner of the reporepo
: name of the reposha
: a git ref or commit sha
Sourcepub async fn repo_list_all_git_refs(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<Reference>, ForgejoError>
pub async fn repo_list_all_git_refs( &self, owner: &str, repo: &str, ) -> Result<Vec<Reference>, ForgejoError>
Get specified ref or filtered repository’s refs
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_list_git_refs(
&self,
owner: &str,
repo: &str,
ref: &str,
) -> Result<Vec<Reference>, ForgejoError>
pub async fn repo_list_git_refs( &self, owner: &str, repo: &str, ref: &str, ) -> Result<Vec<Reference>, ForgejoError>
Get specified ref or filtered repository’s refs
owner
: owner of the reporepo
: name of the reporef
: part or full name of the ref
Sourcepub async fn get_annotated_tag(
&self,
owner: &str,
repo: &str,
sha: &str,
) -> Result<AnnotatedTag, ForgejoError>
pub async fn get_annotated_tag( &self, owner: &str, repo: &str, sha: &str, ) -> Result<AnnotatedTag, ForgejoError>
Gets the tag object of an annotated tag (not lightweight tags)
owner
: owner of the reporepo
: name of the reposha
: sha of the tag. The Git tags API only supports annotated tag objects, not lightweight tags.
Sourcepub async fn get_tree(
&self,
owner: &str,
repo: &str,
sha: &str,
query: GetTreeQuery,
) -> Result<GitTreeResponse, ForgejoError>
pub async fn get_tree( &self, owner: &str, repo: &str, sha: &str, query: GetTreeQuery, ) -> Result<GitTreeResponse, ForgejoError>
Gets the tree of a repository.
owner
: owner of the reporepo
: name of the reposha
: sha of the commit
Sourcepub async fn repo_list_hooks(
&self,
owner: &str,
repo: &str,
query: RepoListHooksQuery,
) -> Result<Vec<Hook>, ForgejoError>
pub async fn repo_list_hooks( &self, owner: &str, repo: &str, query: RepoListHooksQuery, ) -> Result<Vec<Hook>, ForgejoError>
List the hooks in a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_create_hook(
&self,
owner: &str,
repo: &str,
body: CreateHookOption,
) -> Result<Hook, ForgejoError>
pub async fn repo_create_hook( &self, owner: &str, repo: &str, body: CreateHookOption, ) -> Result<Hook, ForgejoError>
Create a hook
owner
: owner of the reporepo
: name of the repobody
: SeeCreateHookOption
Sourcepub async fn repo_list_git_hooks(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<GitHook>, ForgejoError>
pub async fn repo_list_git_hooks( &self, owner: &str, repo: &str, ) -> Result<Vec<GitHook>, ForgejoError>
List the Git hooks in a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_get_git_hook(
&self,
owner: &str,
repo: &str,
id: &str,
) -> Result<GitHook, ForgejoError>
pub async fn repo_get_git_hook( &self, owner: &str, repo: &str, id: &str, ) -> Result<GitHook, ForgejoError>
Get a Git hook
owner
: owner of the reporepo
: name of the repoid
: id of the hook to get
Sourcepub async fn repo_delete_git_hook(
&self,
owner: &str,
repo: &str,
id: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_git_hook( &self, owner: &str, repo: &str, id: &str, ) -> Result<(), ForgejoError>
Delete a Git hook in a repository
owner
: owner of the reporepo
: name of the repoid
: id of the hook to get
Sourcepub async fn repo_edit_git_hook(
&self,
owner: &str,
repo: &str,
id: &str,
body: EditGitHookOption,
) -> Result<GitHook, ForgejoError>
pub async fn repo_edit_git_hook( &self, owner: &str, repo: &str, id: &str, body: EditGitHookOption, ) -> Result<GitHook, ForgejoError>
Edit a Git hook in a repository
owner
: owner of the reporepo
: name of the repoid
: id of the hook to getbody
: SeeEditGitHookOption
Sourcepub async fn repo_get_hook(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<Hook, ForgejoError>
pub async fn repo_get_hook( &self, owner: &str, repo: &str, id: u64, ) -> Result<Hook, ForgejoError>
Get a hook
owner
: owner of the reporepo
: name of the repoid
: id of the hook to get
Sourcepub async fn repo_delete_hook(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<(), ForgejoError>
pub async fn repo_delete_hook( &self, owner: &str, repo: &str, id: u64, ) -> Result<(), ForgejoError>
Delete a hook in a repository
owner
: owner of the reporepo
: name of the repoid
: id of the hook to delete
Sourcepub async fn repo_edit_hook(
&self,
owner: &str,
repo: &str,
id: u64,
body: EditHookOption,
) -> Result<Hook, ForgejoError>
pub async fn repo_edit_hook( &self, owner: &str, repo: &str, id: u64, body: EditHookOption, ) -> Result<Hook, ForgejoError>
Edit a hook in a repository
owner
: owner of the reporepo
: name of the repoid
: index of the hookbody
: SeeEditHookOption
Sourcepub async fn repo_test_hook(
&self,
owner: &str,
repo: &str,
id: u64,
query: RepoTestHookQuery,
) -> Result<(), ForgejoError>
pub async fn repo_test_hook( &self, owner: &str, repo: &str, id: u64, query: RepoTestHookQuery, ) -> Result<(), ForgejoError>
Test a push webhook
owner
: owner of the reporepo
: name of the repoid
: id of the hook to test
Sourcepub async fn repo_get_issue_config(
&self,
owner: &str,
repo: &str,
) -> Result<IssueConfig, ForgejoError>
pub async fn repo_get_issue_config( &self, owner: &str, repo: &str, ) -> Result<IssueConfig, ForgejoError>
Returns the issue config for a repo
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_validate_issue_config(
&self,
owner: &str,
repo: &str,
) -> Result<IssueConfigValidation, ForgejoError>
pub async fn repo_validate_issue_config( &self, owner: &str, repo: &str, ) -> Result<IssueConfigValidation, ForgejoError>
Returns the validation information for a issue config
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_get_issue_templates(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<IssueTemplate>, ForgejoError>
pub async fn repo_get_issue_templates( &self, owner: &str, repo: &str, ) -> Result<Vec<IssueTemplate>, ForgejoError>
Get available issue templates for a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn issue_list_issues(
&self,
owner: &str,
repo: &str,
query: IssueListIssuesQuery,
) -> Result<Vec<Issue>, ForgejoError>
pub async fn issue_list_issues( &self, owner: &str, repo: &str, query: IssueListIssuesQuery, ) -> Result<Vec<Issue>, ForgejoError>
List a repository’s issues
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn issue_create_issue(
&self,
owner: &str,
repo: &str,
body: CreateIssueOption,
) -> Result<Issue, ForgejoError>
pub async fn issue_create_issue( &self, owner: &str, repo: &str, body: CreateIssueOption, ) -> Result<Issue, ForgejoError>
Create an issue. If using deadline only the date will be taken into account, and time of day ignored.
owner
: owner of the reporepo
: name of the repobody
: SeeCreateIssueOption
Sourcepub async fn issue_get_repo_comments(
&self,
owner: &str,
repo: &str,
query: IssueGetRepoCommentsQuery,
) -> Result<Vec<Comment>, ForgejoError>
pub async fn issue_get_repo_comments( &self, owner: &str, repo: &str, query: IssueGetRepoCommentsQuery, ) -> Result<Vec<Comment>, ForgejoError>
List all comments in a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn issue_get_comment(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<Option<Comment>, ForgejoError>
pub async fn issue_get_comment( &self, owner: &str, repo: &str, id: u64, ) -> Result<Option<Comment>, ForgejoError>
Get a comment
owner
: owner of the reporepo
: name of the repoid
: id of the comment
Sourcepub async fn issue_delete_comment(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<(), ForgejoError>
pub async fn issue_delete_comment( &self, owner: &str, repo: &str, id: u64, ) -> Result<(), ForgejoError>
Delete a comment
owner
: owner of the reporepo
: name of the repoid
: id of comment to delete
Sourcepub async fn issue_edit_comment(
&self,
owner: &str,
repo: &str,
id: u64,
body: EditIssueCommentOption,
) -> Result<Option<Comment>, ForgejoError>
pub async fn issue_edit_comment( &self, owner: &str, repo: &str, id: u64, body: EditIssueCommentOption, ) -> Result<Option<Comment>, ForgejoError>
Edit a comment
owner
: owner of the reporepo
: name of the repoid
: id of the comment to editbody
: SeeEditIssueCommentOption
Sourcepub async fn issue_list_issue_comment_attachments(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<Vec<Attachment>, ForgejoError>
pub async fn issue_list_issue_comment_attachments( &self, owner: &str, repo: &str, id: u64, ) -> Result<Vec<Attachment>, ForgejoError>
List comment’s attachments
owner
: owner of the reporepo
: name of the repoid
: id of the comment
Sourcepub async fn issue_create_issue_comment_attachment(
&self,
owner: &str,
repo: &str,
id: u64,
attachment: Vec<u8>,
query: IssueCreateIssueCommentAttachmentQuery,
) -> Result<Attachment, ForgejoError>
pub async fn issue_create_issue_comment_attachment( &self, owner: &str, repo: &str, id: u64, attachment: Vec<u8>, query: IssueCreateIssueCommentAttachmentQuery, ) -> Result<Attachment, ForgejoError>
Create a comment attachment
owner
: owner of the reporepo
: name of the repoid
: id of the commentattachment
: attachment to upload
Sourcepub async fn issue_get_issue_comment_attachment(
&self,
owner: &str,
repo: &str,
id: u64,
attachment_id: u64,
) -> Result<Attachment, ForgejoError>
pub async fn issue_get_issue_comment_attachment( &self, owner: &str, repo: &str, id: u64, attachment_id: u64, ) -> Result<Attachment, ForgejoError>
Get a comment attachment
owner
: owner of the reporepo
: name of the repoid
: id of the commentattachment_id
: id of the attachment to get
Sourcepub async fn issue_delete_issue_comment_attachment(
&self,
owner: &str,
repo: &str,
id: u64,
attachment_id: u64,
) -> Result<(), ForgejoError>
pub async fn issue_delete_issue_comment_attachment( &self, owner: &str, repo: &str, id: u64, attachment_id: u64, ) -> Result<(), ForgejoError>
Delete a comment attachment
owner
: owner of the reporepo
: name of the repoid
: id of the commentattachment_id
: id of the attachment to delete
Sourcepub async fn issue_edit_issue_comment_attachment(
&self,
owner: &str,
repo: &str,
id: u64,
attachment_id: u64,
body: EditAttachmentOptions,
) -> Result<Attachment, ForgejoError>
pub async fn issue_edit_issue_comment_attachment( &self, owner: &str, repo: &str, id: u64, attachment_id: u64, body: EditAttachmentOptions, ) -> Result<Attachment, ForgejoError>
Edit a comment attachment
owner
: owner of the reporepo
: name of the repoid
: id of the commentattachment_id
: id of the attachment to editbody
: SeeEditAttachmentOptions
Sourcepub async fn issue_get_comment_reactions(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<Vec<Reaction>, ForgejoError>
pub async fn issue_get_comment_reactions( &self, owner: &str, repo: &str, id: u64, ) -> Result<Vec<Reaction>, ForgejoError>
Get a list of reactions from a comment of an issue
owner
: owner of the reporepo
: name of the repoid
: id of the comment to edit
Sourcepub async fn issue_post_comment_reaction(
&self,
owner: &str,
repo: &str,
id: u64,
content: EditReactionOption,
) -> Result<Reaction, ForgejoError>
pub async fn issue_post_comment_reaction( &self, owner: &str, repo: &str, id: u64, content: EditReactionOption, ) -> Result<Reaction, ForgejoError>
Add a reaction to a comment of an issue
owner
: owner of the reporepo
: name of the repoid
: id of the comment to editcontent
: SeeEditReactionOption
Sourcepub async fn issue_delete_comment_reaction(
&self,
owner: &str,
repo: &str,
id: u64,
content: EditReactionOption,
) -> Result<(), ForgejoError>
pub async fn issue_delete_comment_reaction( &self, owner: &str, repo: &str, id: u64, content: EditReactionOption, ) -> Result<(), ForgejoError>
Remove a reaction from a comment of an issue
owner
: owner of the reporepo
: name of the repoid
: id of the comment to editcontent
: SeeEditReactionOption
Sourcepub async fn repo_list_pinned_issues(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<Issue>, ForgejoError>
pub async fn repo_list_pinned_issues( &self, owner: &str, repo: &str, ) -> Result<Vec<Issue>, ForgejoError>
List a repo’s pinned issues
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn issue_get_issue(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<Issue, ForgejoError>
pub async fn issue_get_issue( &self, owner: &str, repo: &str, index: u64, ) -> Result<Issue, ForgejoError>
Get an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issue to get
Sourcepub async fn issue_delete(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<(), ForgejoError>
pub async fn issue_delete( &self, owner: &str, repo: &str, index: u64, ) -> Result<(), ForgejoError>
Delete an issue
owner
: owner of the reporepo
: name of the repoindex
: index of issue to delete
Sourcepub async fn issue_edit_issue(
&self,
owner: &str,
repo: &str,
index: u64,
body: EditIssueOption,
) -> Result<Issue, ForgejoError>
pub async fn issue_edit_issue( &self, owner: &str, repo: &str, index: u64, body: EditIssueOption, ) -> Result<Issue, ForgejoError>
Edit an issue. If using deadline only the date will be taken into account, and time of day ignored.
owner
: owner of the reporepo
: name of the repoindex
: index of the issue to editbody
: SeeEditIssueOption
Sourcepub async fn issue_list_issue_attachments(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<Vec<Attachment>, ForgejoError>
pub async fn issue_list_issue_attachments( &self, owner: &str, repo: &str, index: u64, ) -> Result<Vec<Attachment>, ForgejoError>
List issue’s attachments
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_create_issue_attachment(
&self,
owner: &str,
repo: &str,
index: u64,
attachment: Vec<u8>,
query: IssueCreateIssueAttachmentQuery,
) -> Result<Attachment, ForgejoError>
pub async fn issue_create_issue_attachment( &self, owner: &str, repo: &str, index: u64, attachment: Vec<u8>, query: IssueCreateIssueAttachmentQuery, ) -> Result<Attachment, ForgejoError>
Create an issue attachment
owner
: owner of the reporepo
: name of the repoindex
: index of the issueattachment
: attachment to upload
Sourcepub async fn issue_get_issue_attachment(
&self,
owner: &str,
repo: &str,
index: u64,
attachment_id: u64,
) -> Result<Attachment, ForgejoError>
pub async fn issue_get_issue_attachment( &self, owner: &str, repo: &str, index: u64, attachment_id: u64, ) -> Result<Attachment, ForgejoError>
Get an issue attachment
owner
: owner of the reporepo
: name of the repoindex
: index of the issueattachment_id
: id of the attachment to get
Sourcepub async fn issue_delete_issue_attachment(
&self,
owner: &str,
repo: &str,
index: u64,
attachment_id: u64,
) -> Result<(), ForgejoError>
pub async fn issue_delete_issue_attachment( &self, owner: &str, repo: &str, index: u64, attachment_id: u64, ) -> Result<(), ForgejoError>
Delete an issue attachment
owner
: owner of the reporepo
: name of the repoindex
: index of the issueattachment_id
: id of the attachment to delete
Sourcepub async fn issue_edit_issue_attachment(
&self,
owner: &str,
repo: &str,
index: u64,
attachment_id: u64,
body: EditAttachmentOptions,
) -> Result<Attachment, ForgejoError>
pub async fn issue_edit_issue_attachment( &self, owner: &str, repo: &str, index: u64, attachment_id: u64, body: EditAttachmentOptions, ) -> Result<Attachment, ForgejoError>
Edit an issue attachment
owner
: owner of the reporepo
: name of the repoindex
: index of the issueattachment_id
: id of the attachment to editbody
: SeeEditAttachmentOptions
Sourcepub async fn issue_list_blocks(
&self,
owner: &str,
repo: &str,
index: &str,
query: IssueListBlocksQuery,
) -> Result<Vec<Issue>, ForgejoError>
pub async fn issue_list_blocks( &self, owner: &str, repo: &str, index: &str, query: IssueListBlocksQuery, ) -> Result<Vec<Issue>, ForgejoError>
List issues that are blocked by this issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_create_issue_blocking(
&self,
owner: &str,
repo: &str,
index: &str,
body: IssueMeta,
) -> Result<Issue, ForgejoError>
pub async fn issue_create_issue_blocking( &self, owner: &str, repo: &str, index: &str, body: IssueMeta, ) -> Result<Issue, ForgejoError>
Block the issue given in the body by the issue in path
owner
: owner of the reporepo
: name of the repoindex
: index of the issuebody
: SeeIssueMeta
Sourcepub async fn issue_remove_issue_blocking(
&self,
owner: &str,
repo: &str,
index: &str,
body: IssueMeta,
) -> Result<Issue, ForgejoError>
pub async fn issue_remove_issue_blocking( &self, owner: &str, repo: &str, index: &str, body: IssueMeta, ) -> Result<Issue, ForgejoError>
Unblock the issue given in the body by the issue in path
owner
: owner of the reporepo
: name of the repoindex
: index of the issuebody
: SeeIssueMeta
Sourcepub async fn issue_get_comments(
&self,
owner: &str,
repo: &str,
index: u64,
query: IssueGetCommentsQuery,
) -> Result<Vec<Comment>, ForgejoError>
pub async fn issue_get_comments( &self, owner: &str, repo: &str, index: u64, query: IssueGetCommentsQuery, ) -> Result<Vec<Comment>, ForgejoError>
List all comments on an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_create_comment(
&self,
owner: &str,
repo: &str,
index: u64,
body: CreateIssueCommentOption,
) -> Result<Comment, ForgejoError>
pub async fn issue_create_comment( &self, owner: &str, repo: &str, index: u64, body: CreateIssueCommentOption, ) -> Result<Comment, ForgejoError>
Add a comment to an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issuebody
: SeeCreateIssueCommentOption
Sourcepub async fn issue_delete_comment_deprecated(
&self,
owner: &str,
repo: &str,
index: u32,
id: u64,
) -> Result<(), ForgejoError>
pub async fn issue_delete_comment_deprecated( &self, owner: &str, repo: &str, index: u32, id: u64, ) -> Result<(), ForgejoError>
Delete a comment
owner
: owner of the reporepo
: name of the repoindex
: this parameter is ignoredid
: id of comment to delete
Sourcepub async fn issue_edit_comment_deprecated(
&self,
owner: &str,
repo: &str,
index: u32,
id: u64,
body: EditIssueCommentOption,
) -> Result<Option<Comment>, ForgejoError>
pub async fn issue_edit_comment_deprecated( &self, owner: &str, repo: &str, index: u32, id: u64, body: EditIssueCommentOption, ) -> Result<Option<Comment>, ForgejoError>
Edit a comment
owner
: owner of the reporepo
: name of the repoindex
: this parameter is ignoredid
: id of the comment to editbody
: SeeEditIssueCommentOption
Sourcepub async fn issue_edit_issue_deadline(
&self,
owner: &str,
repo: &str,
index: u64,
body: EditDeadlineOption,
) -> Result<IssueDeadline, ForgejoError>
pub async fn issue_edit_issue_deadline( &self, owner: &str, repo: &str, index: u64, body: EditDeadlineOption, ) -> Result<IssueDeadline, ForgejoError>
Set an issue deadline. If set to null, the deadline is deleted. If using deadline only the date will be taken into account, and time of day ignored.
owner
: owner of the reporepo
: name of the repoindex
: index of the issue to create or update a deadline onbody
: SeeEditDeadlineOption
Sourcepub async fn issue_list_issue_dependencies(
&self,
owner: &str,
repo: &str,
index: &str,
query: IssueListIssueDependenciesQuery,
) -> Result<Vec<Issue>, ForgejoError>
pub async fn issue_list_issue_dependencies( &self, owner: &str, repo: &str, index: &str, query: IssueListIssueDependenciesQuery, ) -> Result<Vec<Issue>, ForgejoError>
List an issue’s dependencies, i.e all issues that block this issue.
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_create_issue_dependencies(
&self,
owner: &str,
repo: &str,
index: &str,
body: IssueMeta,
) -> Result<Issue, ForgejoError>
pub async fn issue_create_issue_dependencies( &self, owner: &str, repo: &str, index: &str, body: IssueMeta, ) -> Result<Issue, ForgejoError>
Make the issue in the url depend on the issue in the form.
owner
: owner of the reporepo
: name of the repoindex
: index of the issuebody
: SeeIssueMeta
Sourcepub async fn issue_remove_issue_dependencies(
&self,
owner: &str,
repo: &str,
index: &str,
body: IssueMeta,
) -> Result<Issue, ForgejoError>
pub async fn issue_remove_issue_dependencies( &self, owner: &str, repo: &str, index: &str, body: IssueMeta, ) -> Result<Issue, ForgejoError>
Remove an issue dependency
owner
: owner of the reporepo
: name of the repoindex
: index of the issuebody
: SeeIssueMeta
Sourcepub async fn issue_get_labels(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<Vec<Label>, ForgejoError>
pub async fn issue_get_labels( &self, owner: &str, repo: &str, index: u64, ) -> Result<Vec<Label>, ForgejoError>
Get an issue’s labels
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_replace_labels(
&self,
owner: &str,
repo: &str,
index: u64,
body: IssueLabelsOption,
) -> Result<Vec<Label>, ForgejoError>
pub async fn issue_replace_labels( &self, owner: &str, repo: &str, index: u64, body: IssueLabelsOption, ) -> Result<Vec<Label>, ForgejoError>
Replace an issue’s labels
owner
: owner of the reporepo
: name of the repoindex
: index of the issuebody
: SeeIssueLabelsOption
Sourcepub async fn issue_add_label(
&self,
owner: &str,
repo: &str,
index: u64,
body: IssueLabelsOption,
) -> Result<Vec<Label>, ForgejoError>
pub async fn issue_add_label( &self, owner: &str, repo: &str, index: u64, body: IssueLabelsOption, ) -> Result<Vec<Label>, ForgejoError>
Add a label to an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issuebody
: SeeIssueLabelsOption
Sourcepub async fn issue_clear_labels(
&self,
owner: &str,
repo: &str,
index: u64,
body: DeleteLabelsOption,
) -> Result<(), ForgejoError>
pub async fn issue_clear_labels( &self, owner: &str, repo: &str, index: u64, body: DeleteLabelsOption, ) -> Result<(), ForgejoError>
Remove all labels from an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issuebody
: SeeDeleteLabelsOption
Sourcepub async fn issue_remove_label(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
body: DeleteLabelsOption,
) -> Result<(), ForgejoError>
pub async fn issue_remove_label( &self, owner: &str, repo: &str, index: u64, id: u64, body: DeleteLabelsOption, ) -> Result<(), ForgejoError>
Remove a label from an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issueid
: id of the label to removebody
: SeeDeleteLabelsOption
Sourcepub async fn pin_issue(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<(), ForgejoError>
pub async fn pin_issue( &self, owner: &str, repo: &str, index: u64, ) -> Result<(), ForgejoError>
Pin an Issue
owner
: owner of the reporepo
: name of the repoindex
: index of issue to pin
Sourcepub async fn unpin_issue(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<(), ForgejoError>
pub async fn unpin_issue( &self, owner: &str, repo: &str, index: u64, ) -> Result<(), ForgejoError>
Unpin an Issue
owner
: owner of the reporepo
: name of the repoindex
: index of issue to unpin
Sourcepub async fn move_issue_pin(
&self,
owner: &str,
repo: &str,
index: u64,
position: u64,
) -> Result<(), ForgejoError>
pub async fn move_issue_pin( &self, owner: &str, repo: &str, index: u64, position: u64, ) -> Result<(), ForgejoError>
Moves the Pin to the given Position
owner
: owner of the reporepo
: name of the repoindex
: index of issueposition
: the new position
Sourcepub async fn issue_get_issue_reactions(
&self,
owner: &str,
repo: &str,
index: u64,
query: IssueGetIssueReactionsQuery,
) -> Result<Vec<Reaction>, ForgejoError>
pub async fn issue_get_issue_reactions( &self, owner: &str, repo: &str, index: u64, query: IssueGetIssueReactionsQuery, ) -> Result<Vec<Reaction>, ForgejoError>
Get a list reactions of an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_post_issue_reaction(
&self,
owner: &str,
repo: &str,
index: u64,
content: EditReactionOption,
) -> Result<Reaction, ForgejoError>
pub async fn issue_post_issue_reaction( &self, owner: &str, repo: &str, index: u64, content: EditReactionOption, ) -> Result<Reaction, ForgejoError>
Add a reaction to an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issuecontent
: SeeEditReactionOption
Sourcepub async fn issue_delete_issue_reaction(
&self,
owner: &str,
repo: &str,
index: u64,
content: EditReactionOption,
) -> Result<(), ForgejoError>
pub async fn issue_delete_issue_reaction( &self, owner: &str, repo: &str, index: u64, content: EditReactionOption, ) -> Result<(), ForgejoError>
Remove a reaction from an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issuecontent
: SeeEditReactionOption
Sourcepub async fn issue_delete_stop_watch(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<(), ForgejoError>
pub async fn issue_delete_stop_watch( &self, owner: &str, repo: &str, index: u64, ) -> Result<(), ForgejoError>
Delete an issue’s existing stopwatch.
owner
: owner of the reporepo
: name of the repoindex
: index of the issue to stop the stopwatch on
Sourcepub async fn issue_start_stop_watch(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<(), ForgejoError>
pub async fn issue_start_stop_watch( &self, owner: &str, repo: &str, index: u64, ) -> Result<(), ForgejoError>
Start stopwatch on an issue.
owner
: owner of the reporepo
: name of the repoindex
: index of the issue to create the stopwatch on
Sourcepub async fn issue_stop_stop_watch(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<(), ForgejoError>
pub async fn issue_stop_stop_watch( &self, owner: &str, repo: &str, index: u64, ) -> Result<(), ForgejoError>
Stop an issue’s existing stopwatch.
owner
: owner of the reporepo
: name of the repoindex
: index of the issue to stop the stopwatch on
Sourcepub async fn issue_subscriptions(
&self,
owner: &str,
repo: &str,
index: u64,
query: IssueSubscriptionsQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn issue_subscriptions( &self, owner: &str, repo: &str, index: u64, query: IssueSubscriptionsQuery, ) -> Result<Vec<User>, ForgejoError>
Get users who subscribed on an issue.
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_check_subscription(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<WatchInfo, ForgejoError>
pub async fn issue_check_subscription( &self, owner: &str, repo: &str, index: u64, ) -> Result<WatchInfo, ForgejoError>
Check if user is subscribed to an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_add_subscription(
&self,
owner: &str,
repo: &str,
index: u64,
user: &str,
) -> Result<(), ForgejoError>
pub async fn issue_add_subscription( &self, owner: &str, repo: &str, index: u64, user: &str, ) -> Result<(), ForgejoError>
Subscribe user to issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issueuser
: user to subscribe
Sourcepub async fn issue_delete_subscription(
&self,
owner: &str,
repo: &str,
index: u64,
user: &str,
) -> Result<(), ForgejoError>
pub async fn issue_delete_subscription( &self, owner: &str, repo: &str, index: u64, user: &str, ) -> Result<(), ForgejoError>
Unsubscribe user from issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issueuser
: user witch unsubscribe
Sourcepub async fn issue_get_comments_and_timeline(
&self,
owner: &str,
repo: &str,
index: u64,
query: IssueGetCommentsAndTimelineQuery,
) -> Result<Vec<TimelineComment>, ForgejoError>
pub async fn issue_get_comments_and_timeline( &self, owner: &str, repo: &str, index: u64, query: IssueGetCommentsAndTimelineQuery, ) -> Result<Vec<TimelineComment>, ForgejoError>
List all comments and events on an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_tracked_times(
&self,
owner: &str,
repo: &str,
index: u64,
query: IssueTrackedTimesQuery,
) -> Result<Vec<TrackedTime>, ForgejoError>
pub async fn issue_tracked_times( &self, owner: &str, repo: &str, index: u64, query: IssueTrackedTimesQuery, ) -> Result<Vec<TrackedTime>, ForgejoError>
List an issue’s tracked times
owner
: owner of the reporepo
: name of the repoindex
: index of the issue
Sourcepub async fn issue_add_time(
&self,
owner: &str,
repo: &str,
index: u64,
body: AddTimeOption,
) -> Result<TrackedTime, ForgejoError>
pub async fn issue_add_time( &self, owner: &str, repo: &str, index: u64, body: AddTimeOption, ) -> Result<TrackedTime, ForgejoError>
Add tracked time to a issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issuebody
: SeeAddTimeOption
Sourcepub async fn issue_reset_time(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<(), ForgejoError>
pub async fn issue_reset_time( &self, owner: &str, repo: &str, index: u64, ) -> Result<(), ForgejoError>
Reset a tracked time of an issue
owner
: owner of the reporepo
: name of the repoindex
: index of the issue to add tracked time to
Sourcepub async fn issue_delete_time(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
) -> Result<(), ForgejoError>
pub async fn issue_delete_time( &self, owner: &str, repo: &str, index: u64, id: u64, ) -> Result<(), ForgejoError>
Delete specific tracked time
owner
: owner of the reporepo
: name of the repoindex
: index of the issueid
: id of time to delete
Sourcepub async fn repo_list_keys(
&self,
owner: &str,
repo: &str,
query: RepoListKeysQuery,
) -> Result<Vec<DeployKey>, ForgejoError>
pub async fn repo_list_keys( &self, owner: &str, repo: &str, query: RepoListKeysQuery, ) -> Result<Vec<DeployKey>, ForgejoError>
List a repository’s keys
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_create_key(
&self,
owner: &str,
repo: &str,
body: CreateKeyOption,
) -> Result<DeployKey, ForgejoError>
pub async fn repo_create_key( &self, owner: &str, repo: &str, body: CreateKeyOption, ) -> Result<DeployKey, ForgejoError>
Add a key to a repository
owner
: owner of the reporepo
: name of the repobody
: SeeCreateKeyOption
Sourcepub async fn repo_get_key(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<DeployKey, ForgejoError>
pub async fn repo_get_key( &self, owner: &str, repo: &str, id: u64, ) -> Result<DeployKey, ForgejoError>
Get a repository’s key by id
owner
: owner of the reporepo
: name of the repoid
: id of the key to get
Sourcepub async fn repo_delete_key(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<(), ForgejoError>
pub async fn repo_delete_key( &self, owner: &str, repo: &str, id: u64, ) -> Result<(), ForgejoError>
Delete a key from a repository
owner
: owner of the reporepo
: name of the repoid
: id of the key to delete
Sourcepub async fn issue_list_labels(
&self,
owner: &str,
repo: &str,
query: IssueListLabelsQuery,
) -> Result<Vec<Label>, ForgejoError>
pub async fn issue_list_labels( &self, owner: &str, repo: &str, query: IssueListLabelsQuery, ) -> Result<Vec<Label>, ForgejoError>
Get all of a repository’s labels
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn issue_create_label(
&self,
owner: &str,
repo: &str,
body: CreateLabelOption,
) -> Result<Label, ForgejoError>
pub async fn issue_create_label( &self, owner: &str, repo: &str, body: CreateLabelOption, ) -> Result<Label, ForgejoError>
Create a label
owner
: owner of the reporepo
: name of the repobody
: SeeCreateLabelOption
Sourcepub async fn issue_get_label(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<Label, ForgejoError>
pub async fn issue_get_label( &self, owner: &str, repo: &str, id: u64, ) -> Result<Label, ForgejoError>
Get a single label
owner
: owner of the reporepo
: name of the repoid
: id of the label to get
Sourcepub async fn issue_delete_label(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<(), ForgejoError>
pub async fn issue_delete_label( &self, owner: &str, repo: &str, id: u64, ) -> Result<(), ForgejoError>
Delete a label
owner
: owner of the reporepo
: name of the repoid
: id of the label to delete
Sourcepub async fn issue_edit_label(
&self,
owner: &str,
repo: &str,
id: u64,
body: EditLabelOption,
) -> Result<Label, ForgejoError>
pub async fn issue_edit_label( &self, owner: &str, repo: &str, id: u64, body: EditLabelOption, ) -> Result<Label, ForgejoError>
Update a label
owner
: owner of the reporepo
: name of the repoid
: id of the label to editbody
: SeeEditLabelOption
Sourcepub async fn repo_get_languages(
&self,
owner: &str,
repo: &str,
) -> Result<BTreeMap<String, i64>, ForgejoError>
pub async fn repo_get_languages( &self, owner: &str, repo: &str, ) -> Result<BTreeMap<String, i64>, ForgejoError>
Get languages and number of bytes of code written
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_get_raw_file_or_lfs(
&self,
owner: &str,
repo: &str,
filepath: &str,
query: RepoGetRawFileOrLfsQuery,
) -> Result<Vec<u8>, ForgejoError>
pub async fn repo_get_raw_file_or_lfs( &self, owner: &str, repo: &str, filepath: &str, query: RepoGetRawFileOrLfsQuery, ) -> Result<Vec<u8>, ForgejoError>
Get a file or it’s LFS object from a repository
owner
: owner of the reporepo
: name of the repofilepath
: filepath of the file to get
Sourcepub async fn issue_get_milestones_list(
&self,
owner: &str,
repo: &str,
query: IssueGetMilestonesListQuery,
) -> Result<Vec<Milestone>, ForgejoError>
pub async fn issue_get_milestones_list( &self, owner: &str, repo: &str, query: IssueGetMilestonesListQuery, ) -> Result<Vec<Milestone>, ForgejoError>
Get all of a repository’s opened milestones
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn issue_create_milestone(
&self,
owner: &str,
repo: &str,
body: CreateMilestoneOption,
) -> Result<Milestone, ForgejoError>
pub async fn issue_create_milestone( &self, owner: &str, repo: &str, body: CreateMilestoneOption, ) -> Result<Milestone, ForgejoError>
Create a milestone
owner
: owner of the reporepo
: name of the repobody
: SeeCreateMilestoneOption
Sourcepub async fn issue_get_milestone(
&self,
owner: &str,
repo: &str,
id: &str,
) -> Result<Milestone, ForgejoError>
pub async fn issue_get_milestone( &self, owner: &str, repo: &str, id: &str, ) -> Result<Milestone, ForgejoError>
Get a milestone
owner
: owner of the reporepo
: name of the repoid
: the milestone to get, identified by ID and if not available by name
Sourcepub async fn issue_delete_milestone(
&self,
owner: &str,
repo: &str,
id: &str,
) -> Result<(), ForgejoError>
pub async fn issue_delete_milestone( &self, owner: &str, repo: &str, id: &str, ) -> Result<(), ForgejoError>
Delete a milestone
owner
: owner of the reporepo
: name of the repoid
: the milestone to delete, identified by ID and if not available by name
Sourcepub async fn issue_edit_milestone(
&self,
owner: &str,
repo: &str,
id: &str,
body: EditMilestoneOption,
) -> Result<Milestone, ForgejoError>
pub async fn issue_edit_milestone( &self, owner: &str, repo: &str, id: &str, body: EditMilestoneOption, ) -> Result<Milestone, ForgejoError>
Update a milestone
owner
: owner of the reporepo
: name of the repoid
: the milestone to edit, identified by ID and if not available by namebody
: SeeEditMilestoneOption
Sourcepub async fn repo_mirror_sync(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn repo_mirror_sync( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Sync a mirrored repository
owner
: owner of the repo to syncrepo
: name of the repo to sync
Sourcepub async fn repo_new_pin_allowed(
&self,
owner: &str,
repo: &str,
) -> Result<NewIssuePinsAllowed, ForgejoError>
pub async fn repo_new_pin_allowed( &self, owner: &str, repo: &str, ) -> Result<NewIssuePinsAllowed, ForgejoError>
Returns if new Issue Pins are allowed
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn notify_get_repo_list(
&self,
owner: &str,
repo: &str,
query: NotifyGetRepoListQuery,
) -> Result<Vec<NotificationThread>, ForgejoError>
pub async fn notify_get_repo_list( &self, owner: &str, repo: &str, query: NotifyGetRepoListQuery, ) -> Result<Vec<NotificationThread>, ForgejoError>
List users’s notification threads on a specific repo
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn notify_read_repo_list(
&self,
owner: &str,
repo: &str,
query: NotifyReadRepoListQuery,
) -> Result<Vec<NotificationThread>, ForgejoError>
pub async fn notify_read_repo_list( &self, owner: &str, repo: &str, query: NotifyReadRepoListQuery, ) -> Result<Vec<NotificationThread>, ForgejoError>
Mark notification threads as read, pinned or unread on a specific repo
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_list_pull_requests(
&self,
owner: &str,
repo: &str,
query: RepoListPullRequestsQuery,
) -> Result<Vec<PullRequest>, ForgejoError>
pub async fn repo_list_pull_requests( &self, owner: &str, repo: &str, query: RepoListPullRequestsQuery, ) -> Result<Vec<PullRequest>, ForgejoError>
List a repo’s pull requests
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_create_pull_request(
&self,
owner: &str,
repo: &str,
body: CreatePullRequestOption,
) -> Result<PullRequest, ForgejoError>
pub async fn repo_create_pull_request( &self, owner: &str, repo: &str, body: CreatePullRequestOption, ) -> Result<PullRequest, ForgejoError>
Create a pull request
owner
: owner of the reporepo
: name of the repobody
: SeeCreatePullRequestOption
Sourcepub async fn repo_list_pinned_pull_requests(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<PullRequest>, ForgejoError>
pub async fn repo_list_pinned_pull_requests( &self, owner: &str, repo: &str, ) -> Result<Vec<PullRequest>, ForgejoError>
List a repo’s pinned pull requests
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_get_pull_request_by_base_head(
&self,
owner: &str,
repo: &str,
base: &str,
head: &str,
) -> Result<PullRequest, ForgejoError>
pub async fn repo_get_pull_request_by_base_head( &self, owner: &str, repo: &str, base: &str, head: &str, ) -> Result<PullRequest, ForgejoError>
Get a pull request by base and head
owner
: owner of the reporepo
: name of the repobase
: base of the pull request to gethead
: head of the pull request to get
Sourcepub async fn repo_get_pull_request(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<PullRequest, ForgejoError>
pub async fn repo_get_pull_request( &self, owner: &str, repo: &str, index: u64, ) -> Result<PullRequest, ForgejoError>
Get a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request to get
Sourcepub async fn repo_edit_pull_request(
&self,
owner: &str,
repo: &str,
index: u64,
body: EditPullRequestOption,
) -> Result<PullRequest, ForgejoError>
pub async fn repo_edit_pull_request( &self, owner: &str, repo: &str, index: u64, body: EditPullRequestOption, ) -> Result<PullRequest, ForgejoError>
Update a pull request. If using deadline only the date will be taken into account, and time of day ignored.
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request to editbody
: SeeEditPullRequestOption
Sourcepub async fn repo_download_pull_diff_or_patch(
&self,
owner: &str,
repo: &str,
index: u64,
diff_type: &str,
query: RepoDownloadPullDiffOrPatchQuery,
) -> Result<String, ForgejoError>
pub async fn repo_download_pull_diff_or_patch( &self, owner: &str, repo: &str, index: u64, diff_type: &str, query: RepoDownloadPullDiffOrPatchQuery, ) -> Result<String, ForgejoError>
Get a pull request diff or patch
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request to getdiffType
: whether the output is diff or patch
Sourcepub async fn repo_get_pull_request_commits(
&self,
owner: &str,
repo: &str,
index: u64,
query: RepoGetPullRequestCommitsQuery,
) -> Result<(CommitListHeaders, Vec<Commit>), ForgejoError>
pub async fn repo_get_pull_request_commits( &self, owner: &str, repo: &str, index: u64, query: RepoGetPullRequestCommitsQuery, ) -> Result<(CommitListHeaders, Vec<Commit>), ForgejoError>
Get commits for a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request to get
Sourcepub async fn repo_get_pull_request_files(
&self,
owner: &str,
repo: &str,
index: u64,
query: RepoGetPullRequestFilesQuery,
) -> Result<(ChangedFileListHeaders, Vec<ChangedFile>), ForgejoError>
pub async fn repo_get_pull_request_files( &self, owner: &str, repo: &str, index: u64, query: RepoGetPullRequestFilesQuery, ) -> Result<(ChangedFileListHeaders, Vec<ChangedFile>), ForgejoError>
Get changed files for a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request to get
Sourcepub async fn repo_pull_request_is_merged(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<(), ForgejoError>
pub async fn repo_pull_request_is_merged( &self, owner: &str, repo: &str, index: u64, ) -> Result<(), ForgejoError>
Check if a pull request has been merged
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request
Sourcepub async fn repo_merge_pull_request(
&self,
owner: &str,
repo: &str,
index: u64,
body: MergePullRequestOption,
) -> Result<(), ForgejoError>
pub async fn repo_merge_pull_request( &self, owner: &str, repo: &str, index: u64, body: MergePullRequestOption, ) -> Result<(), ForgejoError>
Merge a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request to mergebody
: SeeMergePullRequestOption
Sourcepub async fn repo_cancel_scheduled_auto_merge(
&self,
owner: &str,
repo: &str,
index: u64,
) -> Result<(), ForgejoError>
pub async fn repo_cancel_scheduled_auto_merge( &self, owner: &str, repo: &str, index: u64, ) -> Result<(), ForgejoError>
Cancel the scheduled auto merge for the given pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request to merge
Sourcepub async fn repo_create_pull_review_requests(
&self,
owner: &str,
repo: &str,
index: u64,
body: PullReviewRequestOptions,
) -> Result<Vec<PullReview>, ForgejoError>
pub async fn repo_create_pull_review_requests( &self, owner: &str, repo: &str, index: u64, body: PullReviewRequestOptions, ) -> Result<Vec<PullReview>, ForgejoError>
create review requests for a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestbody
: SeePullReviewRequestOptions
Sourcepub async fn repo_delete_pull_review_requests(
&self,
owner: &str,
repo: &str,
index: u64,
body: PullReviewRequestOptions,
) -> Result<(), ForgejoError>
pub async fn repo_delete_pull_review_requests( &self, owner: &str, repo: &str, index: u64, body: PullReviewRequestOptions, ) -> Result<(), ForgejoError>
cancel review requests for a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestbody
: SeePullReviewRequestOptions
Sourcepub async fn repo_list_pull_reviews(
&self,
owner: &str,
repo: &str,
index: u64,
query: RepoListPullReviewsQuery,
) -> Result<Vec<PullReview>, ForgejoError>
pub async fn repo_list_pull_reviews( &self, owner: &str, repo: &str, index: u64, query: RepoListPullReviewsQuery, ) -> Result<Vec<PullReview>, ForgejoError>
List all reviews for a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request
Sourcepub async fn repo_create_pull_review(
&self,
owner: &str,
repo: &str,
index: u64,
body: CreatePullReviewOptions,
) -> Result<PullReview, ForgejoError>
pub async fn repo_create_pull_review( &self, owner: &str, repo: &str, index: u64, body: CreatePullReviewOptions, ) -> Result<PullReview, ForgejoError>
Create a review to an pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestbody
: SeeCreatePullReviewOptions
Sourcepub async fn repo_get_pull_review(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
) -> Result<PullReview, ForgejoError>
pub async fn repo_get_pull_review( &self, owner: &str, repo: &str, index: u64, id: u64, ) -> Result<PullReview, ForgejoError>
Get a specific review for a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestid
: id of the review
Sourcepub async fn repo_submit_pull_review(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
body: SubmitPullReviewOptions,
) -> Result<PullReview, ForgejoError>
pub async fn repo_submit_pull_review( &self, owner: &str, repo: &str, index: u64, id: u64, body: SubmitPullReviewOptions, ) -> Result<PullReview, ForgejoError>
Submit a pending review to an pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestid
: id of the reviewbody
: SeeSubmitPullReviewOptions
Sourcepub async fn repo_delete_pull_review(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
) -> Result<(), ForgejoError>
pub async fn repo_delete_pull_review( &self, owner: &str, repo: &str, index: u64, id: u64, ) -> Result<(), ForgejoError>
Delete a specific review from a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestid
: id of the review
Sourcepub async fn repo_get_pull_review_comments(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
) -> Result<Vec<PullReviewComment>, ForgejoError>
pub async fn repo_get_pull_review_comments( &self, owner: &str, repo: &str, index: u64, id: u64, ) -> Result<Vec<PullReviewComment>, ForgejoError>
Get a specific review for a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestid
: id of the review
Sourcepub async fn repo_create_pull_review_comment(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
body: Value,
) -> Result<PullReviewComment, ForgejoError>
pub async fn repo_create_pull_review_comment( &self, owner: &str, repo: &str, index: u64, id: u64, body: Value, ) -> Result<PullReviewComment, ForgejoError>
Add a new comment to a pull request review
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestid
: id of the reviewbody
: Seeserde_json::Value
Sourcepub async fn repo_get_pull_review_comment(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
comment: u64,
) -> Result<PullReviewComment, ForgejoError>
pub async fn repo_get_pull_review_comment( &self, owner: &str, repo: &str, index: u64, id: u64, comment: u64, ) -> Result<PullReviewComment, ForgejoError>
Get a pull review comment
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestid
: id of the reviewcomment
: id of the comment
Sourcepub async fn repo_delete_pull_review_comment(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
comment: u64,
) -> Result<(), ForgejoError>
pub async fn repo_delete_pull_review_comment( &self, owner: &str, repo: &str, index: u64, id: u64, comment: u64, ) -> Result<(), ForgejoError>
Delete a pull review comment
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestid
: id of the reviewcomment
: id of the comment
Sourcepub async fn repo_dismiss_pull_review(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
body: DismissPullReviewOptions,
) -> Result<PullReview, ForgejoError>
pub async fn repo_dismiss_pull_review( &self, owner: &str, repo: &str, index: u64, id: u64, body: DismissPullReviewOptions, ) -> Result<PullReview, ForgejoError>
Dismiss a review for a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestid
: id of the reviewbody
: SeeDismissPullReviewOptions
Sourcepub async fn repo_un_dismiss_pull_review(
&self,
owner: &str,
repo: &str,
index: u64,
id: u64,
) -> Result<PullReview, ForgejoError>
pub async fn repo_un_dismiss_pull_review( &self, owner: &str, repo: &str, index: u64, id: u64, ) -> Result<PullReview, ForgejoError>
Cancel to dismiss a review for a pull request
owner
: owner of the reporepo
: name of the repoindex
: index of the pull requestid
: id of the review
Sourcepub async fn repo_update_pull_request(
&self,
owner: &str,
repo: &str,
index: u64,
query: RepoUpdatePullRequestQuery,
) -> Result<(), ForgejoError>
pub async fn repo_update_pull_request( &self, owner: &str, repo: &str, index: u64, query: RepoUpdatePullRequestQuery, ) -> Result<(), ForgejoError>
Merge PR’s baseBranch into headBranch
owner
: owner of the reporepo
: name of the repoindex
: index of the pull request to get
Sourcepub async fn repo_list_push_mirrors(
&self,
owner: &str,
repo: &str,
query: RepoListPushMirrorsQuery,
) -> Result<Vec<PushMirror>, ForgejoError>
pub async fn repo_list_push_mirrors( &self, owner: &str, repo: &str, query: RepoListPushMirrorsQuery, ) -> Result<Vec<PushMirror>, ForgejoError>
Get all push mirrors of the repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_add_push_mirror(
&self,
owner: &str,
repo: &str,
body: CreatePushMirrorOption,
) -> Result<PushMirror, ForgejoError>
pub async fn repo_add_push_mirror( &self, owner: &str, repo: &str, body: CreatePushMirrorOption, ) -> Result<PushMirror, ForgejoError>
add a push mirror to the repository
owner
: owner of the reporepo
: name of the repobody
: SeeCreatePushMirrorOption
Sourcepub async fn repo_push_mirror_sync(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn repo_push_mirror_sync( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Sync all push mirrored repository
owner
: owner of the repo to syncrepo
: name of the repo to sync
Sourcepub async fn repo_get_push_mirror_by_remote_name(
&self,
owner: &str,
repo: &str,
name: &str,
) -> Result<PushMirror, ForgejoError>
pub async fn repo_get_push_mirror_by_remote_name( &self, owner: &str, repo: &str, name: &str, ) -> Result<PushMirror, ForgejoError>
Get push mirror of the repository by remoteName
owner
: owner of the reporepo
: name of the reponame
: remote name of push mirror
Sourcepub async fn repo_delete_push_mirror(
&self,
owner: &str,
repo: &str,
name: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_push_mirror( &self, owner: &str, repo: &str, name: &str, ) -> Result<(), ForgejoError>
deletes a push mirror from a repository by remoteName
owner
: owner of the reporepo
: name of the reponame
: remote name of the pushMirror
Sourcepub async fn repo_get_raw_file(
&self,
owner: &str,
repo: &str,
filepath: &str,
query: RepoGetRawFileQuery,
) -> Result<Vec<u8>, ForgejoError>
pub async fn repo_get_raw_file( &self, owner: &str, repo: &str, filepath: &str, query: RepoGetRawFileQuery, ) -> Result<Vec<u8>, ForgejoError>
Get a file from a repository
owner
: owner of the reporepo
: name of the repofilepath
: filepath of the file to get
Sourcepub async fn repo_list_releases(
&self,
owner: &str,
repo: &str,
query: RepoListReleasesQuery,
) -> Result<Vec<Release>, ForgejoError>
pub async fn repo_list_releases( &self, owner: &str, repo: &str, query: RepoListReleasesQuery, ) -> Result<Vec<Release>, ForgejoError>
List a repo’s releases
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_create_release(
&self,
owner: &str,
repo: &str,
body: CreateReleaseOption,
) -> Result<Release, ForgejoError>
pub async fn repo_create_release( &self, owner: &str, repo: &str, body: CreateReleaseOption, ) -> Result<Release, ForgejoError>
Create a release
owner
: owner of the reporepo
: name of the repobody
: SeeCreateReleaseOption
Sourcepub async fn repo_get_latest_release(
&self,
owner: &str,
repo: &str,
) -> Result<Release, ForgejoError>
pub async fn repo_get_latest_release( &self, owner: &str, repo: &str, ) -> Result<Release, ForgejoError>
Gets the most recent non-prerelease, non-draft release of a repository, sorted by created_at
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_get_release_by_tag(
&self,
owner: &str,
repo: &str,
tag: &str,
) -> Result<Release, ForgejoError>
pub async fn repo_get_release_by_tag( &self, owner: &str, repo: &str, tag: &str, ) -> Result<Release, ForgejoError>
Get a release by tag name
owner
: owner of the reporepo
: name of the repotag
: tag name of the release to get
Sourcepub async fn repo_delete_release_by_tag(
&self,
owner: &str,
repo: &str,
tag: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_release_by_tag( &self, owner: &str, repo: &str, tag: &str, ) -> Result<(), ForgejoError>
Delete a release by tag name
owner
: owner of the reporepo
: name of the repotag
: tag name of the release to delete
Sourcepub async fn repo_get_release(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<Release, ForgejoError>
pub async fn repo_get_release( &self, owner: &str, repo: &str, id: u64, ) -> Result<Release, ForgejoError>
Get a release
owner
: owner of the reporepo
: name of the repoid
: id of the release to get
Sourcepub async fn repo_delete_release(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<(), ForgejoError>
pub async fn repo_delete_release( &self, owner: &str, repo: &str, id: u64, ) -> Result<(), ForgejoError>
Delete a release
owner
: owner of the reporepo
: name of the repoid
: id of the release to delete
Sourcepub async fn repo_edit_release(
&self,
owner: &str,
repo: &str,
id: u64,
body: EditReleaseOption,
) -> Result<Release, ForgejoError>
pub async fn repo_edit_release( &self, owner: &str, repo: &str, id: u64, body: EditReleaseOption, ) -> Result<Release, ForgejoError>
Update a release
owner
: owner of the reporepo
: name of the repoid
: id of the release to editbody
: SeeEditReleaseOption
Sourcepub async fn repo_list_release_attachments(
&self,
owner: &str,
repo: &str,
id: u64,
) -> Result<Vec<Attachment>, ForgejoError>
pub async fn repo_list_release_attachments( &self, owner: &str, repo: &str, id: u64, ) -> Result<Vec<Attachment>, ForgejoError>
List release’s attachments
owner
: owner of the reporepo
: name of the repoid
: id of the release
Sourcepub async fn repo_create_release_attachment(
&self,
owner: &str,
repo: &str,
id: u64,
attachment: Vec<u8>,
query: RepoCreateReleaseAttachmentQuery,
) -> Result<Attachment, ForgejoError>
pub async fn repo_create_release_attachment( &self, owner: &str, repo: &str, id: u64, attachment: Vec<u8>, query: RepoCreateReleaseAttachmentQuery, ) -> Result<Attachment, ForgejoError>
Create a release attachment
owner
: owner of the reporepo
: name of the repoid
: id of the releaseattachment
: attachment to upload
Sourcepub async fn repo_get_release_attachment(
&self,
owner: &str,
repo: &str,
id: u64,
attachment_id: u64,
) -> Result<Attachment, ForgejoError>
pub async fn repo_get_release_attachment( &self, owner: &str, repo: &str, id: u64, attachment_id: u64, ) -> Result<Attachment, ForgejoError>
Get a release attachment
owner
: owner of the reporepo
: name of the repoid
: id of the releaseattachment_id
: id of the attachment to get
Sourcepub async fn repo_delete_release_attachment(
&self,
owner: &str,
repo: &str,
id: u64,
attachment_id: u64,
) -> Result<(), ForgejoError>
pub async fn repo_delete_release_attachment( &self, owner: &str, repo: &str, id: u64, attachment_id: u64, ) -> Result<(), ForgejoError>
Delete a release attachment
owner
: owner of the reporepo
: name of the repoid
: id of the releaseattachment_id
: id of the attachment to delete
Sourcepub async fn repo_edit_release_attachment(
&self,
owner: &str,
repo: &str,
id: u64,
attachment_id: u64,
body: EditAttachmentOptions,
) -> Result<Attachment, ForgejoError>
pub async fn repo_edit_release_attachment( &self, owner: &str, repo: &str, id: u64, attachment_id: u64, body: EditAttachmentOptions, ) -> Result<Attachment, ForgejoError>
Edit a release attachment
owner
: owner of the reporepo
: name of the repoid
: id of the releaseattachment_id
: id of the attachment to editbody
: SeeEditAttachmentOptions
Sourcepub async fn repo_get_reviewers(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<User>, ForgejoError>
pub async fn repo_get_reviewers( &self, owner: &str, repo: &str, ) -> Result<Vec<User>, ForgejoError>
Return all users that can be requested to review in this repo
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_get_runner_registration_token(
&self,
owner: &str,
repo: &str,
) -> Result<RegistrationTokenHeaders, ForgejoError>
pub async fn repo_get_runner_registration_token( &self, owner: &str, repo: &str, ) -> Result<RegistrationTokenHeaders, ForgejoError>
Get a repository’s actions runner registration token
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_signing_key(
&self,
owner: &str,
repo: &str,
) -> Result<String, ForgejoError>
pub async fn repo_signing_key( &self, owner: &str, repo: &str, ) -> Result<String, ForgejoError>
Get signing-key.gpg for given repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_list_stargazers(
&self,
owner: &str,
repo: &str,
query: RepoListStargazersQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn repo_list_stargazers( &self, owner: &str, repo: &str, query: RepoListStargazersQuery, ) -> Result<Vec<User>, ForgejoError>
List a repo’s stargazers
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_list_statuses(
&self,
owner: &str,
repo: &str,
sha: &str,
query: RepoListStatusesQuery,
) -> Result<Vec<CommitStatus>, ForgejoError>
pub async fn repo_list_statuses( &self, owner: &str, repo: &str, sha: &str, query: RepoListStatusesQuery, ) -> Result<Vec<CommitStatus>, ForgejoError>
Get a commit’s statuses
owner
: owner of the reporepo
: name of the reposha
: sha of the commit
Sourcepub async fn repo_create_status(
&self,
owner: &str,
repo: &str,
sha: &str,
body: CreateStatusOption,
) -> Result<CommitStatus, ForgejoError>
pub async fn repo_create_status( &self, owner: &str, repo: &str, sha: &str, body: CreateStatusOption, ) -> Result<CommitStatus, ForgejoError>
Create a commit status
owner
: owner of the reporepo
: name of the reposha
: sha of the commitbody
: SeeCreateStatusOption
Sourcepub async fn repo_list_subscribers(
&self,
owner: &str,
repo: &str,
query: RepoListSubscribersQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn repo_list_subscribers( &self, owner: &str, repo: &str, query: RepoListSubscribersQuery, ) -> Result<Vec<User>, ForgejoError>
List a repo’s watchers
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn user_current_check_subscription(
&self,
owner: &str,
repo: &str,
) -> Result<WatchInfo, ForgejoError>
pub async fn user_current_check_subscription( &self, owner: &str, repo: &str, ) -> Result<WatchInfo, ForgejoError>
Check if the current user is watching a repo
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn user_current_put_subscription(
&self,
owner: &str,
repo: &str,
) -> Result<WatchInfo, ForgejoError>
pub async fn user_current_put_subscription( &self, owner: &str, repo: &str, ) -> Result<WatchInfo, ForgejoError>
Watch a repo
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn user_current_delete_subscription(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn user_current_delete_subscription( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Unwatch a repo
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_list_tag_protection(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<TagProtection>, ForgejoError>
pub async fn repo_list_tag_protection( &self, owner: &str, repo: &str, ) -> Result<Vec<TagProtection>, ForgejoError>
List tag protections for a repository
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_create_tag_protection(
&self,
owner: &str,
repo: &str,
body: CreateTagProtectionOption,
) -> Result<TagProtection, ForgejoError>
pub async fn repo_create_tag_protection( &self, owner: &str, repo: &str, body: CreateTagProtectionOption, ) -> Result<TagProtection, ForgejoError>
Create a tag protections for a repository
owner
: owner of the reporepo
: name of the repobody
: SeeCreateTagProtectionOption
Sourcepub async fn repo_get_tag_protection(
&self,
owner: &str,
repo: &str,
id: u32,
) -> Result<TagProtection, ForgejoError>
pub async fn repo_get_tag_protection( &self, owner: &str, repo: &str, id: u32, ) -> Result<TagProtection, ForgejoError>
Get a specific tag protection for the repository
owner
: owner of the reporepo
: name of the repoid
: id of the tag protect to get
Sourcepub async fn repo_delete_tag_protection(
&self,
owner: &str,
repo: &str,
id: u32,
) -> Result<(), ForgejoError>
pub async fn repo_delete_tag_protection( &self, owner: &str, repo: &str, id: u32, ) -> Result<(), ForgejoError>
Delete a specific tag protection for the repository
owner
: owner of the reporepo
: name of the repoid
: id of protected tag
Sourcepub async fn repo_edit_tag_protection(
&self,
owner: &str,
repo: &str,
id: u32,
body: EditTagProtectionOption,
) -> Result<TagProtection, ForgejoError>
pub async fn repo_edit_tag_protection( &self, owner: &str, repo: &str, id: u32, body: EditTagProtectionOption, ) -> Result<TagProtection, ForgejoError>
Edit a tag protections for a repository. Only fields that are set will be changed
owner
: owner of the reporepo
: name of the repoid
: id of protected tagbody
: SeeEditTagProtectionOption
List a repository’s tags
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_create_tag(
&self,
owner: &str,
repo: &str,
body: CreateTagOption,
) -> Result<Tag, ForgejoError>
pub async fn repo_create_tag( &self, owner: &str, repo: &str, body: CreateTagOption, ) -> Result<Tag, ForgejoError>
Create a new git tag in a repository
owner
: owner of the reporepo
: name of the repobody
: SeeCreateTagOption
Sourcepub async fn repo_get_tag(
&self,
owner: &str,
repo: &str,
tag: &str,
) -> Result<Tag, ForgejoError>
pub async fn repo_get_tag( &self, owner: &str, repo: &str, tag: &str, ) -> Result<Tag, ForgejoError>
Get the tag of a repository by tag name
owner
: owner of the reporepo
: name of the repotag
: name of tag
Sourcepub async fn repo_delete_tag(
&self,
owner: &str,
repo: &str,
tag: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_tag( &self, owner: &str, repo: &str, tag: &str, ) -> Result<(), ForgejoError>
Delete a repository’s tag by name
owner
: owner of the reporepo
: name of the repotag
: name of tag to delete
Sourcepub async fn repo_list_teams(
&self,
owner: &str,
repo: &str,
) -> Result<Vec<Team>, ForgejoError>
pub async fn repo_list_teams( &self, owner: &str, repo: &str, ) -> Result<Vec<Team>, ForgejoError>
List a repository’s teams
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_check_team(
&self,
owner: &str,
repo: &str,
team: &str,
) -> Result<Team, ForgejoError>
pub async fn repo_check_team( &self, owner: &str, repo: &str, team: &str, ) -> Result<Team, ForgejoError>
Check if a team is assigned to a repository
owner
: owner of the reporepo
: name of the repoteam
: team name
Sourcepub async fn repo_add_team(
&self,
owner: &str,
repo: &str,
team: &str,
) -> Result<(), ForgejoError>
pub async fn repo_add_team( &self, owner: &str, repo: &str, team: &str, ) -> Result<(), ForgejoError>
Add a team to a repository
owner
: owner of the reporepo
: name of the repoteam
: team name
Sourcepub async fn repo_delete_team(
&self,
owner: &str,
repo: &str,
team: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_team( &self, owner: &str, repo: &str, team: &str, ) -> Result<(), ForgejoError>
Delete a team from a repository
owner
: owner of the reporepo
: name of the repoteam
: team name
Sourcepub async fn repo_tracked_times(
&self,
owner: &str,
repo: &str,
query: RepoTrackedTimesQuery,
) -> Result<Vec<TrackedTime>, ForgejoError>
pub async fn repo_tracked_times( &self, owner: &str, repo: &str, query: RepoTrackedTimesQuery, ) -> Result<Vec<TrackedTime>, ForgejoError>
List a repo’s tracked times
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn user_tracked_times(
&self,
owner: &str,
repo: &str,
user: &str,
) -> Result<Vec<TrackedTime>, ForgejoError>
pub async fn user_tracked_times( &self, owner: &str, repo: &str, user: &str, ) -> Result<Vec<TrackedTime>, ForgejoError>
List a user’s tracked times in a repo
owner
: owner of the reporepo
: name of the repouser
: username of user
Sourcepub async fn repo_list_topics(
&self,
owner: &str,
repo: &str,
query: RepoListTopicsQuery,
) -> Result<TopicName, ForgejoError>
pub async fn repo_list_topics( &self, owner: &str, repo: &str, query: RepoListTopicsQuery, ) -> Result<TopicName, ForgejoError>
Get list of topics that a repository has
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_update_topics(
&self,
owner: &str,
repo: &str,
body: RepoTopicOptions,
) -> Result<(), ForgejoError>
pub async fn repo_update_topics( &self, owner: &str, repo: &str, body: RepoTopicOptions, ) -> Result<(), ForgejoError>
Replace list of topics for a repository
owner
: owner of the reporepo
: name of the repobody
: SeeRepoTopicOptions
Sourcepub async fn repo_add_topic(
&self,
owner: &str,
repo: &str,
topic: &str,
) -> Result<(), ForgejoError>
pub async fn repo_add_topic( &self, owner: &str, repo: &str, topic: &str, ) -> Result<(), ForgejoError>
Add a topic to a repository
owner
: owner of the reporepo
: name of the repotopic
: name of the topic to add
Sourcepub async fn repo_delete_topic(
&self,
owner: &str,
repo: &str,
topic: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_topic( &self, owner: &str, repo: &str, topic: &str, ) -> Result<(), ForgejoError>
Delete a topic from a repository
owner
: owner of the reporepo
: name of the repotopic
: name of the topic to delete
Sourcepub async fn repo_transfer(
&self,
owner: &str,
repo: &str,
body: TransferRepoOption,
) -> Result<Repository, ForgejoError>
pub async fn repo_transfer( &self, owner: &str, repo: &str, body: TransferRepoOption, ) -> Result<Repository, ForgejoError>
Transfer a repo ownership
owner
: owner of the repo to transferrepo
: name of the repo to transferbody
: Transfer Options SeeTransferRepoOption
Sourcepub async fn accept_repo_transfer(
&self,
owner: &str,
repo: &str,
) -> Result<Repository, ForgejoError>
pub async fn accept_repo_transfer( &self, owner: &str, repo: &str, ) -> Result<Repository, ForgejoError>
Accept a repo transfer
owner
: owner of the repo to transferrepo
: name of the repo to transfer
Sourcepub async fn reject_repo_transfer(
&self,
owner: &str,
repo: &str,
) -> Result<Repository, ForgejoError>
pub async fn reject_repo_transfer( &self, owner: &str, repo: &str, ) -> Result<Repository, ForgejoError>
Reject a repo transfer
owner
: owner of the repo to transferrepo
: name of the repo to transfer
Sourcepub async fn repo_create_wiki_page(
&self,
owner: &str,
repo: &str,
body: CreateWikiPageOptions,
) -> Result<WikiPage, ForgejoError>
pub async fn repo_create_wiki_page( &self, owner: &str, repo: &str, body: CreateWikiPageOptions, ) -> Result<WikiPage, ForgejoError>
Create a wiki page
owner
: owner of the reporepo
: name of the repobody
: SeeCreateWikiPageOptions
Sourcepub async fn repo_get_wiki_page(
&self,
owner: &str,
repo: &str,
page_name: &str,
) -> Result<WikiPage, ForgejoError>
pub async fn repo_get_wiki_page( &self, owner: &str, repo: &str, page_name: &str, ) -> Result<WikiPage, ForgejoError>
Get a wiki page
owner
: owner of the reporepo
: name of the repopageName
: name of the page
Sourcepub async fn repo_delete_wiki_page(
&self,
owner: &str,
repo: &str,
page_name: &str,
) -> Result<(), ForgejoError>
pub async fn repo_delete_wiki_page( &self, owner: &str, repo: &str, page_name: &str, ) -> Result<(), ForgejoError>
Delete a wiki page
owner
: owner of the reporepo
: name of the repopageName
: name of the page
Sourcepub async fn repo_edit_wiki_page(
&self,
owner: &str,
repo: &str,
page_name: &str,
body: CreateWikiPageOptions,
) -> Result<WikiPage, ForgejoError>
pub async fn repo_edit_wiki_page( &self, owner: &str, repo: &str, page_name: &str, body: CreateWikiPageOptions, ) -> Result<WikiPage, ForgejoError>
Edit a wiki page
owner
: owner of the reporepo
: name of the repopageName
: name of the pagebody
: SeeCreateWikiPageOptions
Sourcepub async fn repo_get_wiki_pages(
&self,
owner: &str,
repo: &str,
query: RepoGetWikiPagesQuery,
) -> Result<Vec<WikiPageMetaData>, ForgejoError>
pub async fn repo_get_wiki_pages( &self, owner: &str, repo: &str, query: RepoGetWikiPagesQuery, ) -> Result<Vec<WikiPageMetaData>, ForgejoError>
Get all wiki pages
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn repo_get_wiki_page_revisions(
&self,
owner: &str,
repo: &str,
page_name: &str,
query: RepoGetWikiPageRevisionsQuery,
) -> Result<WikiCommitList, ForgejoError>
pub async fn repo_get_wiki_page_revisions( &self, owner: &str, repo: &str, page_name: &str, query: RepoGetWikiPageRevisionsQuery, ) -> Result<WikiCommitList, ForgejoError>
Get revisions of a wiki page
owner
: owner of the reporepo
: name of the repopageName
: name of the page
Sourcepub async fn generate_repo(
&self,
template_owner: &str,
template_repo: &str,
body: GenerateRepoOption,
) -> Result<Repository, ForgejoError>
pub async fn generate_repo( &self, template_owner: &str, template_repo: &str, body: GenerateRepoOption, ) -> Result<Repository, ForgejoError>
Create a repository using a template
template_owner
: name of the template repository ownertemplate_repo
: name of the template repositorybody
: SeeGenerateRepoOption
Sourcepub async fn repo_get_by_id(&self, id: u64) -> Result<Repository, ForgejoError>
pub async fn repo_get_by_id(&self, id: u64) -> Result<Repository, ForgejoError>
Get a repository by id
id
: id of the repo to get
Sourcepub async fn get_general_api_settings(
&self,
) -> Result<GeneralAPISettings, ForgejoError>
pub async fn get_general_api_settings( &self, ) -> Result<GeneralAPISettings, ForgejoError>
Get instance’s global settings for api
Sourcepub async fn get_general_attachment_settings(
&self,
) -> Result<GeneralAttachmentSettings, ForgejoError>
pub async fn get_general_attachment_settings( &self, ) -> Result<GeneralAttachmentSettings, ForgejoError>
Get instance’s global settings for Attachment
Sourcepub async fn get_general_repository_settings(
&self,
) -> Result<GeneralRepoSettings, ForgejoError>
pub async fn get_general_repository_settings( &self, ) -> Result<GeneralRepoSettings, ForgejoError>
Get instance’s global settings for repositories
Sourcepub async fn get_general_ui_settings(
&self,
) -> Result<GeneralUISettings, ForgejoError>
pub async fn get_general_ui_settings( &self, ) -> Result<GeneralUISettings, ForgejoError>
Get instance’s global settings for ui
Sourcepub async fn get_signing_key(&self) -> Result<String, ForgejoError>
pub async fn get_signing_key(&self) -> Result<String, ForgejoError>
Get default signing-key.gpg
Sourcepub async fn org_get_team(&self, id: u64) -> Result<Team, ForgejoError>
pub async fn org_get_team(&self, id: u64) -> Result<Team, ForgejoError>
Get a team
id
: id of the team to get
Sourcepub async fn org_delete_team(&self, id: u64) -> Result<(), ForgejoError>
pub async fn org_delete_team(&self, id: u64) -> Result<(), ForgejoError>
Delete a team
id
: id of the team to delete
Sourcepub async fn org_edit_team(
&self,
id: u32,
body: EditTeamOption,
) -> Result<Team, ForgejoError>
pub async fn org_edit_team( &self, id: u32, body: EditTeamOption, ) -> Result<Team, ForgejoError>
Edit a team
id
: id of the team to editbody
: SeeEditTeamOption
Sourcepub async fn org_list_team_activity_feeds(
&self,
id: u64,
query: OrgListTeamActivityFeedsQuery,
) -> Result<Vec<Activity>, ForgejoError>
pub async fn org_list_team_activity_feeds( &self, id: u64, query: OrgListTeamActivityFeedsQuery, ) -> Result<Vec<Activity>, ForgejoError>
List a team’s activity feeds
id
: id of the team
Sourcepub async fn org_list_team_members(
&self,
id: u64,
query: OrgListTeamMembersQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn org_list_team_members( &self, id: u64, query: OrgListTeamMembersQuery, ) -> Result<Vec<User>, ForgejoError>
List a team’s members
id
: id of the team
Sourcepub async fn org_list_team_member(
&self,
id: u64,
username: &str,
) -> Result<User, ForgejoError>
pub async fn org_list_team_member( &self, id: u64, username: &str, ) -> Result<User, ForgejoError>
List a particular member of team
id
: id of the teamusername
: username of the member to list
Sourcepub async fn org_add_team_member(
&self,
id: u64,
username: &str,
) -> Result<(), ForgejoError>
pub async fn org_add_team_member( &self, id: u64, username: &str, ) -> Result<(), ForgejoError>
Add a team member
id
: id of the teamusername
: username of the user to add
Sourcepub async fn org_remove_team_member(
&self,
id: u64,
username: &str,
) -> Result<(), ForgejoError>
pub async fn org_remove_team_member( &self, id: u64, username: &str, ) -> Result<(), ForgejoError>
Remove a team member
id
: id of the teamusername
: username of the user to remove
Sourcepub async fn org_list_team_repos(
&self,
id: u64,
query: OrgListTeamReposQuery,
) -> Result<Vec<Repository>, ForgejoError>
pub async fn org_list_team_repos( &self, id: u64, query: OrgListTeamReposQuery, ) -> Result<Vec<Repository>, ForgejoError>
List a team’s repos
id
: id of the team
Sourcepub async fn org_list_team_repo(
&self,
id: u64,
org: &str,
repo: &str,
) -> Result<Repository, ForgejoError>
pub async fn org_list_team_repo( &self, id: u64, org: &str, repo: &str, ) -> Result<Repository, ForgejoError>
List a particular repo of team
id
: id of the teamorg
: organization that owns the repo to listrepo
: name of the repo to list
Sourcepub async fn org_add_team_repository(
&self,
id: u64,
org: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn org_add_team_repository( &self, id: u64, org: &str, repo: &str, ) -> Result<(), ForgejoError>
Add a repository to a team
id
: id of the teamorg
: organization that owns the repo to addrepo
: name of the repo to add
Sourcepub async fn org_remove_team_repository(
&self,
id: u64,
org: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn org_remove_team_repository( &self, id: u64, org: &str, repo: &str, ) -> Result<(), ForgejoError>
Remove a repository from a team
id
: id of the teamorg
: organization that owns the repo to removerepo
: name of the repo to remove
Sourcepub async fn topic_search(
&self,
query: TopicSearchQuery,
) -> Result<Vec<TopicResponse>, ForgejoError>
pub async fn topic_search( &self, query: TopicSearchQuery, ) -> Result<Vec<TopicResponse>, ForgejoError>
search topics via keyword
Sourcepub async fn user_get_current(&self) -> Result<User, ForgejoError>
pub async fn user_get_current(&self) -> Result<User, ForgejoError>
Get the authenticated user
Sourcepub async fn user_get_runner_registration_token(
&self,
) -> Result<RegistrationTokenHeaders, ForgejoError>
pub async fn user_get_runner_registration_token( &self, ) -> Result<RegistrationTokenHeaders, ForgejoError>
Get an user’s actions runner registration token
Sourcepub async fn update_user_secret(
&self,
secretname: &str,
body: CreateOrUpdateSecretOption,
) -> Result<(), ForgejoError>
pub async fn update_user_secret( &self, secretname: &str, body: CreateOrUpdateSecretOption, ) -> Result<(), ForgejoError>
Create or Update a secret value in a user scope
secretname
: name of the secretbody
: SeeCreateOrUpdateSecretOption
Sourcepub async fn delete_user_secret(
&self,
secretname: &str,
) -> Result<(), ForgejoError>
pub async fn delete_user_secret( &self, secretname: &str, ) -> Result<(), ForgejoError>
Delete a secret in a user scope
secretname
: name of the secret
Sourcepub async fn get_user_variables_list(
&self,
query: GetUserVariablesListQuery,
) -> Result<Vec<ActionVariable>, ForgejoError>
pub async fn get_user_variables_list( &self, query: GetUserVariablesListQuery, ) -> Result<Vec<ActionVariable>, ForgejoError>
Get the user-level list of variables which is created by current doer
Sourcepub async fn get_user_variable(
&self,
variablename: &str,
) -> Result<ActionVariable, ForgejoError>
pub async fn get_user_variable( &self, variablename: &str, ) -> Result<ActionVariable, ForgejoError>
Get a user-level variable which is created by current doer
variablename
: name of the variable
Sourcepub async fn update_user_variable(
&self,
variablename: &str,
body: UpdateVariableOption,
) -> Result<(), ForgejoError>
pub async fn update_user_variable( &self, variablename: &str, body: UpdateVariableOption, ) -> Result<(), ForgejoError>
Update a user-level variable which is created by current doer
variablename
: name of the variablebody
: SeeUpdateVariableOption
Sourcepub async fn create_user_variable(
&self,
variablename: &str,
body: CreateVariableOption,
) -> Result<(), ForgejoError>
pub async fn create_user_variable( &self, variablename: &str, body: CreateVariableOption, ) -> Result<(), ForgejoError>
Create a user-level variable
variablename
: name of the variablebody
: SeeCreateVariableOption
Sourcepub async fn delete_user_variable(
&self,
variablename: &str,
) -> Result<(), ForgejoError>
pub async fn delete_user_variable( &self, variablename: &str, ) -> Result<(), ForgejoError>
Delete a user-level variable which is created by current doer
variablename
: name of the variable
Sourcepub async fn user_get_oauth2_applications(
&self,
query: UserGetOAuth2ApplicationsQuery,
) -> Result<Vec<OAuth2Application>, ForgejoError>
pub async fn user_get_oauth2_applications( &self, query: UserGetOAuth2ApplicationsQuery, ) -> Result<Vec<OAuth2Application>, ForgejoError>
List the authenticated user’s oauth2 applications
Sourcepub async fn user_create_oauth2_application(
&self,
body: CreateOAuth2ApplicationOptions,
) -> Result<OAuth2Application, ForgejoError>
pub async fn user_create_oauth2_application( &self, body: CreateOAuth2ApplicationOptions, ) -> Result<OAuth2Application, ForgejoError>
creates a new OAuth2 application
body
: SeeCreateOAuth2ApplicationOptions
Sourcepub async fn user_get_oauth2_application(
&self,
id: u64,
) -> Result<OAuth2Application, ForgejoError>
pub async fn user_get_oauth2_application( &self, id: u64, ) -> Result<OAuth2Application, ForgejoError>
get an OAuth2 Application
id
: Application ID to be found
Sourcepub async fn user_delete_oauth2_application(
&self,
id: u64,
) -> Result<(), ForgejoError>
pub async fn user_delete_oauth2_application( &self, id: u64, ) -> Result<(), ForgejoError>
delete an OAuth2 Application
id
: token to be deleted
Sourcepub async fn user_update_oauth2_application(
&self,
id: u64,
body: CreateOAuth2ApplicationOptions,
) -> Result<OAuth2Application, ForgejoError>
pub async fn user_update_oauth2_application( &self, id: u64, body: CreateOAuth2ApplicationOptions, ) -> Result<OAuth2Application, ForgejoError>
update an OAuth2 Application, this includes regenerating the client secret
id
: application to be updatedbody
: SeeCreateOAuth2ApplicationOptions
Sourcepub async fn user_update_avatar(
&self,
body: UpdateUserAvatarOption,
) -> Result<(), ForgejoError>
pub async fn user_update_avatar( &self, body: UpdateUserAvatarOption, ) -> Result<(), ForgejoError>
Update Avatar
body
: SeeUpdateUserAvatarOption
Sourcepub async fn user_delete_avatar(&self) -> Result<(), ForgejoError>
pub async fn user_delete_avatar(&self) -> Result<(), ForgejoError>
Delete Avatar
Sourcepub async fn user_block_user(&self, username: &str) -> Result<(), ForgejoError>
pub async fn user_block_user(&self, username: &str) -> Result<(), ForgejoError>
Blocks a user from the doer.
username
: username of the user
Sourcepub async fn user_list_emails(&self) -> Result<Vec<Email>, ForgejoError>
pub async fn user_list_emails(&self) -> Result<Vec<Email>, ForgejoError>
List the authenticated user’s email addresses
Sourcepub async fn user_add_email(
&self,
body: CreateEmailOption,
) -> Result<Vec<Email>, ForgejoError>
pub async fn user_add_email( &self, body: CreateEmailOption, ) -> Result<Vec<Email>, ForgejoError>
Add email addresses
body
: SeeCreateEmailOption
Sourcepub async fn user_delete_email(
&self,
body: DeleteEmailOption,
) -> Result<(), ForgejoError>
pub async fn user_delete_email( &self, body: DeleteEmailOption, ) -> Result<(), ForgejoError>
Delete email addresses
body
: SeeDeleteEmailOption
Sourcepub async fn user_current_list_followers(
&self,
query: UserCurrentListFollowersQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn user_current_list_followers( &self, query: UserCurrentListFollowersQuery, ) -> Result<Vec<User>, ForgejoError>
List the authenticated user’s followers
Sourcepub async fn user_current_list_following(
&self,
query: UserCurrentListFollowingQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn user_current_list_following( &self, query: UserCurrentListFollowingQuery, ) -> Result<Vec<User>, ForgejoError>
List the users that the authenticated user is following
Sourcepub async fn user_current_check_following(
&self,
username: &str,
) -> Result<(), ForgejoError>
pub async fn user_current_check_following( &self, username: &str, ) -> Result<(), ForgejoError>
Check whether a user is followed by the authenticated user
username
: username of followed user
Sourcepub async fn user_current_put_follow(
&self,
username: &str,
) -> Result<(), ForgejoError>
pub async fn user_current_put_follow( &self, username: &str, ) -> Result<(), ForgejoError>
Follow a user
username
: username of user to follow
Sourcepub async fn user_current_delete_follow(
&self,
username: &str,
) -> Result<(), ForgejoError>
pub async fn user_current_delete_follow( &self, username: &str, ) -> Result<(), ForgejoError>
Unfollow a user
username
: username of user to unfollow
Sourcepub async fn get_verification_token(&self) -> Result<String, ForgejoError>
pub async fn get_verification_token(&self) -> Result<String, ForgejoError>
Get a Token to verify
Sourcepub async fn user_verify_gpg_key(&self) -> Result<GPGKey, ForgejoError>
pub async fn user_verify_gpg_key(&self) -> Result<GPGKey, ForgejoError>
Verify a GPG key
Sourcepub async fn user_current_list_gpg_keys(
&self,
query: UserCurrentListGpgKeysQuery,
) -> Result<Vec<GPGKey>, ForgejoError>
pub async fn user_current_list_gpg_keys( &self, query: UserCurrentListGpgKeysQuery, ) -> Result<Vec<GPGKey>, ForgejoError>
List the authenticated user’s GPG keys
Sourcepub async fn user_current_post_gpg_key(
&self,
form: CreateGPGKeyOption,
) -> Result<GPGKey, ForgejoError>
pub async fn user_current_post_gpg_key( &self, form: CreateGPGKeyOption, ) -> Result<GPGKey, ForgejoError>
Create a GPG key
Form
: SeeCreateGPGKeyOption
Sourcepub async fn user_current_get_gpg_key(
&self,
id: u64,
) -> Result<GPGKey, ForgejoError>
pub async fn user_current_get_gpg_key( &self, id: u64, ) -> Result<GPGKey, ForgejoError>
Get a GPG key
id
: id of key to get
Sourcepub async fn user_current_delete_gpg_key(
&self,
id: u64,
) -> Result<(), ForgejoError>
pub async fn user_current_delete_gpg_key( &self, id: u64, ) -> Result<(), ForgejoError>
Remove a GPG key
id
: id of key to delete
Sourcepub async fn user_list_hooks(
&self,
query: UserListHooksQuery,
) -> Result<Vec<Hook>, ForgejoError>
pub async fn user_list_hooks( &self, query: UserListHooksQuery, ) -> Result<Vec<Hook>, ForgejoError>
List the authenticated user’s webhooks
Sourcepub async fn user_create_hook(
&self,
body: CreateHookOption,
) -> Result<Hook, ForgejoError>
pub async fn user_create_hook( &self, body: CreateHookOption, ) -> Result<Hook, ForgejoError>
Create a hook
body
: SeeCreateHookOption
Sourcepub async fn user_get_hook(&self, id: u64) -> Result<Hook, ForgejoError>
pub async fn user_get_hook(&self, id: u64) -> Result<Hook, ForgejoError>
Get a hook
id
: id of the hook to get
Sourcepub async fn user_delete_hook(&self, id: u64) -> Result<(), ForgejoError>
pub async fn user_delete_hook(&self, id: u64) -> Result<(), ForgejoError>
Delete a hook
id
: id of the hook to delete
Sourcepub async fn user_edit_hook(
&self,
id: u64,
body: EditHookOption,
) -> Result<Hook, ForgejoError>
pub async fn user_edit_hook( &self, id: u64, body: EditHookOption, ) -> Result<Hook, ForgejoError>
Update a hook
id
: id of the hook to updatebody
: SeeEditHookOption
Sourcepub async fn user_current_list_keys(
&self,
query: UserCurrentListKeysQuery,
) -> Result<Vec<PublicKey>, ForgejoError>
pub async fn user_current_list_keys( &self, query: UserCurrentListKeysQuery, ) -> Result<Vec<PublicKey>, ForgejoError>
List the authenticated user’s public keys
Sourcepub async fn user_current_post_key(
&self,
body: CreateKeyOption,
) -> Result<PublicKey, ForgejoError>
pub async fn user_current_post_key( &self, body: CreateKeyOption, ) -> Result<PublicKey, ForgejoError>
Create a public key
body
: SeeCreateKeyOption
Sourcepub async fn user_current_get_key(
&self,
id: u64,
) -> Result<PublicKey, ForgejoError>
pub async fn user_current_get_key( &self, id: u64, ) -> Result<PublicKey, ForgejoError>
Get a public key
id
: id of key to get
Sourcepub async fn user_current_delete_key(&self, id: u64) -> Result<(), ForgejoError>
pub async fn user_current_delete_key(&self, id: u64) -> Result<(), ForgejoError>
Delete a public key
id
: id of key to delete
Sourcepub async fn user_list_blocked_users(
&self,
query: UserListBlockedUsersQuery,
) -> Result<Vec<BlockedUser>, ForgejoError>
pub async fn user_list_blocked_users( &self, query: UserListBlockedUsersQuery, ) -> Result<Vec<BlockedUser>, ForgejoError>
List the authenticated user’s blocked users
Sourcepub async fn org_list_current_user_orgs(
&self,
query: OrgListCurrentUserOrgsQuery,
) -> Result<Vec<Organization>, ForgejoError>
pub async fn org_list_current_user_orgs( &self, query: OrgListCurrentUserOrgsQuery, ) -> Result<Vec<Organization>, ForgejoError>
List the current user’s organizations
Sourcepub async fn user_current_list_repos(
&self,
query: UserCurrentListReposQuery,
) -> Result<Vec<Repository>, ForgejoError>
pub async fn user_current_list_repos( &self, query: UserCurrentListReposQuery, ) -> Result<Vec<Repository>, ForgejoError>
List the repos that the authenticated user owns
Sourcepub async fn create_current_user_repo(
&self,
body: CreateRepoOption,
) -> Result<Repository, ForgejoError>
pub async fn create_current_user_repo( &self, body: CreateRepoOption, ) -> Result<Repository, ForgejoError>
Create a repository
body
: SeeCreateRepoOption
Sourcepub async fn get_user_settings(&self) -> Result<UserSettings, ForgejoError>
pub async fn get_user_settings(&self) -> Result<UserSettings, ForgejoError>
Get user settings
Sourcepub async fn update_user_settings(
&self,
body: UserSettingsOptions,
) -> Result<UserSettings, ForgejoError>
pub async fn update_user_settings( &self, body: UserSettingsOptions, ) -> Result<UserSettings, ForgejoError>
Update user settings
body
: SeeUserSettingsOptions
Sourcepub async fn user_current_list_starred(
&self,
query: UserCurrentListStarredQuery,
) -> Result<Vec<Repository>, ForgejoError>
pub async fn user_current_list_starred( &self, query: UserCurrentListStarredQuery, ) -> Result<Vec<Repository>, ForgejoError>
The repos that the authenticated user has starred
Sourcepub async fn user_current_check_starring(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn user_current_check_starring( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Whether the authenticated is starring the repo
owner
: owner of the reporepo
: name of the repo
Sourcepub async fn user_current_put_star(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn user_current_put_star( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Star the given repo
owner
: owner of the repo to starrepo
: name of the repo to star
Sourcepub async fn user_current_delete_star(
&self,
owner: &str,
repo: &str,
) -> Result<(), ForgejoError>
pub async fn user_current_delete_star( &self, owner: &str, repo: &str, ) -> Result<(), ForgejoError>
Unstar the given repo
owner
: owner of the repo to unstarrepo
: name of the repo to unstar
Sourcepub async fn user_get_stop_watches(
&self,
query: UserGetStopWatchesQuery,
) -> Result<Vec<StopWatch>, ForgejoError>
pub async fn user_get_stop_watches( &self, query: UserGetStopWatchesQuery, ) -> Result<Vec<StopWatch>, ForgejoError>
Get list of all existing stopwatches
Sourcepub async fn user_current_list_subscriptions(
&self,
query: UserCurrentListSubscriptionsQuery,
) -> Result<Vec<Repository>, ForgejoError>
pub async fn user_current_list_subscriptions( &self, query: UserCurrentListSubscriptionsQuery, ) -> Result<Vec<Repository>, ForgejoError>
List repositories watched by the authenticated user
Sourcepub async fn user_list_teams(
&self,
query: UserListTeamsQuery,
) -> Result<Vec<Team>, ForgejoError>
pub async fn user_list_teams( &self, query: UserListTeamsQuery, ) -> Result<Vec<Team>, ForgejoError>
List all the teams a user belongs to
Sourcepub async fn user_current_tracked_times(
&self,
query: UserCurrentTrackedTimesQuery,
) -> Result<Vec<TrackedTime>, ForgejoError>
pub async fn user_current_tracked_times( &self, query: UserCurrentTrackedTimesQuery, ) -> Result<Vec<TrackedTime>, ForgejoError>
List the current user’s tracked times
Sourcepub async fn user_unblock_user(
&self,
username: &str,
) -> Result<(), ForgejoError>
pub async fn user_unblock_user( &self, username: &str, ) -> Result<(), ForgejoError>
Unblocks a user from the doer.
username
: username of the user
Sourcepub async fn user_search(
&self,
query: UserSearchQuery,
) -> Result<UserSearchResponse, ForgejoError>
pub async fn user_search( &self, query: UserSearchQuery, ) -> Result<UserSearchResponse, ForgejoError>
Search for users
Sourcepub async fn user_get(&self, username: &str) -> Result<User, ForgejoError>
pub async fn user_get(&self, username: &str) -> Result<User, ForgejoError>
Get a user
username
: username of user to get
Sourcepub async fn user_list_activity_feeds(
&self,
username: &str,
query: UserListActivityFeedsQuery,
) -> Result<Vec<Activity>, ForgejoError>
pub async fn user_list_activity_feeds( &self, username: &str, query: UserListActivityFeedsQuery, ) -> Result<Vec<Activity>, ForgejoError>
List a user’s activity feeds
username
: username of user
Sourcepub async fn user_list_followers(
&self,
username: &str,
query: UserListFollowersQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn user_list_followers( &self, username: &str, query: UserListFollowersQuery, ) -> Result<Vec<User>, ForgejoError>
List the given user’s followers
username
: username of user
Sourcepub async fn user_list_following(
&self,
username: &str,
query: UserListFollowingQuery,
) -> Result<Vec<User>, ForgejoError>
pub async fn user_list_following( &self, username: &str, query: UserListFollowingQuery, ) -> Result<Vec<User>, ForgejoError>
List the users that the given user is following
username
: username of user
Sourcepub async fn user_check_following(
&self,
username: &str,
target: &str,
) -> Result<(), ForgejoError>
pub async fn user_check_following( &self, username: &str, target: &str, ) -> Result<(), ForgejoError>
Check if one user is following another user
username
: username of following usertarget
: username of followed user
Sourcepub async fn user_list_gpg_keys(
&self,
username: &str,
query: UserListGpgKeysQuery,
) -> Result<Vec<GPGKey>, ForgejoError>
pub async fn user_list_gpg_keys( &self, username: &str, query: UserListGpgKeysQuery, ) -> Result<Vec<GPGKey>, ForgejoError>
List the given user’s GPG keys
username
: username of user
Sourcepub async fn user_get_heatmap_data(
&self,
username: &str,
) -> Result<Vec<UserHeatmapData>, ForgejoError>
pub async fn user_get_heatmap_data( &self, username: &str, ) -> Result<Vec<UserHeatmapData>, ForgejoError>
Get a user’s heatmap
username
: username of user to get
Sourcepub async fn user_list_keys(
&self,
username: &str,
query: UserListKeysQuery,
) -> Result<Vec<PublicKey>, ForgejoError>
pub async fn user_list_keys( &self, username: &str, query: UserListKeysQuery, ) -> Result<Vec<PublicKey>, ForgejoError>
List the given user’s public keys
username
: username of user
Sourcepub async fn org_list_user_orgs(
&self,
username: &str,
query: OrgListUserOrgsQuery,
) -> Result<Vec<Organization>, ForgejoError>
pub async fn org_list_user_orgs( &self, username: &str, query: OrgListUserOrgsQuery, ) -> Result<Vec<Organization>, ForgejoError>
List a user’s organizations
username
: username of user
Sourcepub async fn org_get_user_permissions(
&self,
username: &str,
org: &str,
) -> Result<OrganizationPermissions, ForgejoError>
pub async fn org_get_user_permissions( &self, username: &str, org: &str, ) -> Result<OrganizationPermissions, ForgejoError>
Get user permissions in organization
username
: username of userorg
: name of the organization
Sourcepub async fn user_list_repos(
&self,
username: &str,
query: UserListReposQuery,
) -> Result<Vec<Repository>, ForgejoError>
pub async fn user_list_repos( &self, username: &str, query: UserListReposQuery, ) -> Result<Vec<Repository>, ForgejoError>
List the repos owned by the given user
username
: username of user
Sourcepub async fn user_list_starred(
&self,
username: &str,
query: UserListStarredQuery,
) -> Result<Vec<Repository>, ForgejoError>
pub async fn user_list_starred( &self, username: &str, query: UserListStarredQuery, ) -> Result<Vec<Repository>, ForgejoError>
The repos that the given user has starred
username
: username of user
Sourcepub async fn user_list_subscriptions(
&self,
username: &str,
query: UserListSubscriptionsQuery,
) -> Result<Vec<Repository>, ForgejoError>
pub async fn user_list_subscriptions( &self, username: &str, query: UserListSubscriptionsQuery, ) -> Result<Vec<Repository>, ForgejoError>
List the repositories watched by a user
username
: username of the user
Sourcepub async fn user_get_tokens(
&self,
username: &str,
query: UserGetTokensQuery,
) -> Result<Vec<AccessToken>, ForgejoError>
pub async fn user_get_tokens( &self, username: &str, query: UserGetTokensQuery, ) -> Result<Vec<AccessToken>, ForgejoError>
List the authenticated user’s access tokens
username
: username of user
Sourcepub async fn user_create_token(
&self,
username: &str,
body: CreateAccessTokenOption,
) -> Result<AccessToken, ForgejoError>
pub async fn user_create_token( &self, username: &str, body: CreateAccessTokenOption, ) -> Result<AccessToken, ForgejoError>
Create an access token
username
: username of userbody
: SeeCreateAccessTokenOption
Sourcepub async fn user_delete_access_token(
&self,
username: &str,
token: &str,
) -> Result<(), ForgejoError>
pub async fn user_delete_access_token( &self, username: &str, token: &str, ) -> Result<(), ForgejoError>
delete an access token
username
: username of usertoken
: token to be deleted, identified by ID and if not available by name
Sourcepub async fn get_version(&self) -> Result<ServerVersion, ForgejoError>
pub async fn get_version(&self) -> Result<ServerVersion, ForgejoError>
Returns the version of the Forgejo application
pub async fn download_release_attachment( &self, owner: &str, repo: &str, release: u64, attach: u64, ) -> Result<Bytes, ForgejoError>
Sourcepub async fn oauth_get_access_token(
&self,
body: OAuthTokenRequest<'_>,
) -> Result<OAuthToken, ForgejoError>
pub async fn oauth_get_access_token( &self, body: OAuthTokenRequest<'_>, ) -> Result<OAuthToken, ForgejoError>
Requests a new OAuth2 access token
More info at Forgejo’s docs.
Trait Implementations§
Source§impl Deref for BergClient
impl Deref for BergClient
Auto Trait Implementations§
impl Freeze for BergClient
impl !RefUnwindSafe for BergClient
impl Send for BergClient
impl Sync for BergClient
impl Unpin for BergClient
impl !UnwindSafe for BergClient
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
Source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more