### Get Installed System Hooks (Java)

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This snippet fetches a list of all system hooks currently installed on the GitLab instance. System hooks are used for executing actions when certain events occur across the entire GitLab server. The result is a List of SystemHook objects.

```java
List<SystemHook> hooks = gitLabApi.getSystemHooksApi().getSystemHooks();
```

--------------------------------

### Get GitLab Server Application Settings with gitlab4j-api

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This example shows how to retrieve the current application settings for the GitLab server using the ApplicationSettingsApi. This operation does not require any specific input parameters. The result is an ApplicationSettings object.

```java
ApplicationSettings appSettings = gitLabApi.getApplicationSettingsApi().getAppliationSettings();
```

--------------------------------

### Get Deploy Keys for Authenticated User with gitlab4j-api

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This example demonstrates fetching a list of DeployKeys associated with the currently authenticated user using the DeployKeysApi. No input parameters are required. The result is a list of DeployKey objects.

```java
// Get a list of DeployKeys for the authenticated user
List<DeployKey> deployKeys = gitLabApi.getDeployKeysApi().getDeployKeys();
```

--------------------------------

### Get Environments for a Project with gitlab4j-api

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This example shows how to fetch a list of Environments belonging to a specific project using the EnvironmentsApi. The projectId is a required input. The output is a list of Environment objects.

```java
// Get a list of Environments for the specified project
List<Environment> environments = gitLabApi.getEnvironmentsApi().getEnvironments(projectId);
```

--------------------------------

### License Templates API

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Get a list of available open-source license templates.

```APIDOC
## GET /api/v4/templates/licenses

### Description
Get a list of open-source license templates.

### Method
GET

### Endpoint
/api/v4/templates/licenses

### Parameters
No parameters required.

### Request Example
(No request body needed for GET request)

### Response
#### Success Response (200)
- **license_templates** (array) - List of LicenseTemplate objects.

#### Response Example
```json
[
  {
    "key": "mit",
    "name": "MIT License"
  }
]
```
```

--------------------------------

### Get Project Tags (Java)

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This code example retrieves a list of all tags associated with a specific project, identified by its project ID. Tags are commonly used for version control and marking release points. The output is a List of Tag objects.

```java
List<Tag> tags = gitLabApi.getTagsApi().getTags(projectId);
```

--------------------------------

### Get User Information (Java)

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This example demonstrates how to fetch the details of a specific user by their user ID. It returns a User object containing information like name, username, and email. Requires the user ID as input.

```java
User user = gitLabApi.getUserApi().getUser(1);
```

--------------------------------

### GitLab Repository File Management Examples

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

This snippet demonstrates how to manage files within a GitLab repository using the RepositoryFileApi. It includes operations for retrieving file content, checking file existence, creating, updating, and deleting files. This requires the gitlab4j-api library and a connection to a GitLab instance.

```java
import org.gitlab4j.api.RepositoryFileApi;
import org.gitlab4j.api.models.RepositoryFile;
import java.util.Optional;

RepositoryFileApi fileApi = gitLabApi.getRepositoryFileApi();

// Get a file from repository
RepositoryFile file = fileApi.getFile(1234L, "path/to/file.txt", "main");
System.out.println("Content: " + file.getDecodedContentAsString());
System.out.println("Size: " + file.getSize());
System.out.println("Last commit: " + file.getLastCommitId());

// Get file with Optional
Optional<RepositoryFile> optionalFile = fileApi.getOptionalFile(1234L, "config.yml", "main");
if (optionalFile.isPresent()) {
    RepositoryFile config = optionalFile.get();
    System.out.println(config.getDecodedContentAsString());
}

// Get raw file content
String rawContent = fileApi.getRawFile(1234L, "main", "README.md");
System.out.println(rawContent);

// Check if file exists
boolean exists = fileApi.existsFile(1234L, "path/to/file.txt", "main");

// Create a new file
RepositoryFile newFile = new RepositoryFile();
newFile.setFilePath("path/to/newfile.txt");
newFile.setContent("Initial content");
RepositoryFile created = fileApi.createFile(
    1234L,
    newFile,
    "main",
    "Add new file"
);

// Update an existing file
file.setContent("Updated content");
RepositoryFile updated = fileApi.updateFile(
    1234L,
    file,
    "main",
    "Update file content"
);

// Delete a file
fileApi.deleteFile(1234L, "path/to/oldfile.txt", "main", "Remove old file");
```

--------------------------------

### Login to GitLab Server (Java)

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This example shows how to log in to a GitLab server using provided credentials and retrieve session information. It requires the user's username, email, and password. This is a foundational step for many authenticated API operations.

```java
gitLabApi.getSessionApi().login("your-username", "your-email", "your-password");
```

--------------------------------

### Get License Templates

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of open-source license templates available in GitLab. This method does not require any parameters.

```java
// Get a list of open sourcse license templates
List<LicenseTemplate> licenses = gitLabApi.getLicenseTemplatesApi().getLicenseTemplates();
```

--------------------------------

### GitLab Commits API Examples

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

This snippet shows how to interact with GitLab commits using the CommitsApi. It covers fetching commits by branch or date range, retrieving a specific commit, viewing commit diffs, creating new commits with file changes, cherry-picking, and reverting commits. It requires the gitlab4j-api library and a GitLab instance connection.

```java
import org.gitlab4j.api.CommitsApi;
import org.gitlab4j.api.models.Commit;
import org.gitlab4j.api.models.CommitAction;
import org.gitlab4j.api.models.CommitPayload;
import org.gitlab4j.api.models.CommitAction.Action;
import java.util.Arrays;
import java.util.Date;

CommitsApi commitsApi = gitLabApi.getCommitsApi();

// Get commits for a branch
List<Commit> commits = commitsApi.getCommits(1234L, "main");

// Get commits within a time range
Date since = ISO8601.toDate("2024-01-01T00:00:00Z");
Date until = new Date();
List<Commit> recentCommits = commitsApi.getCommits(1234L, "main", since, until);

// Get a specific commit
Commit commit = commitsApi.getCommit(1234L, "abc123def");
System.out.println("Author: " + commit.getAuthorName());
System.out.println("Message: " + commit.getMessage());
System.out.println("Stats: +" + commit.getStats().getAdditions() +
                   " -" + commit.getStats().getDeletions());

// Get commit diff
List<Diff> diffs = commitsApi.getDiff(1234L, "abc123def");
diffs.forEach(diff -> {
    System.out.println("File: " + diff.getNewPath());
    System.out.println(diff.getDiff());
});

// Create a commit with file changes
CommitAction createFile = new CommitAction()
    .withAction(Action.CREATE)
    .withFilePath("path/to/newfile.txt")
    .withContent("File content here");

CommitAction updateFile = new CommitAction()
    .withAction(Action.UPDATE)
    .withFilePath("path/to/existing.txt")
    .withContent("Updated content");

CommitPayload payload = new CommitPayload()
    .withBranch("main")
    .withCommitMessage("Add and update files")
    .withActions(Arrays.asList(createFile, updateFile));

Commit newCommit = commitsApi.createCommit(1234L, payload);

// Cherry-pick a commit
Commit cherryPicked = commitsApi.cherryPickCommit(1234L, "abc123def", "target-branch");

// Revert a commit
Commit reverted = commitsApi.revertCommit(1234L, "abc123def", "main");
```

--------------------------------

### Manage GitLab Projects

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

Covers operations on GitLab projects using the ProjectApi, including retrieving all projects, paginating through projects, getting a specific project by ID or path, creating a new project, updating project settings, retrieving project statistics, and deleting a project.

```java
import org.gitlab4j.api.ProjectApi;
import org.gitlab4j.api.models.Project;
import org.gitlab4j.api.models.ProjectFilter;
import org.gitlab4j.api.Pager;
import org.gitlab4j.api.models.Visibility;
import org.gitlab4j.api.models.ProjectFetches;
import java.util.List;

// Assume gitLabApi is an initialized GitLabApi instance
// GitLabApi gitLabApi = new GitLabApi("https://gitlab.example.com", "your-personal-access-token");

ProjectApi projectApi = gitLabApi.getProjectApi();

// Get all accessible projects
List<Project> projects = projectApi.getProjects();

// Get projects with pagination
Pager<Project> pager = projectApi.getProjects(50); // 50 items per page
while (pager.hasNext()) {
    List<Project> page = pager.next();
    for (Project project : page) {
        System.out.println(project.getName() + ": " + project.getWebUrl());
    }
}

// Get a specific project by ID or path
Project project = projectApi.getProject("my-group/my-project");
Project projectById = projectApi.getProject(1234L);

// Create a new project
Project newProject = new Project()
    .withName("my-new-project")
    .withDescription("A demonstration project")
    .withIssuesEnabled(true)
    .withMergeRequestsEnabled(true)
    .withWikiEnabled(true)
    .withSnippetsEnabled(true)
    .withVisibility(Visibility.PRIVATE);
Project created = projectApi.createProject(newProject);

// Update project settings
project.setDescription("Updated description");
Project updated = projectApi.updateProject(project);

// Get project statistics
ProjectFetches stats = projectApi.getProjectStatistics(1234L);
System.out.println("Total fetches: " + stats.getFetches().getTotal());

// Delete a project
projectApi.deleteProject(1234L);
```

--------------------------------

### Get Releases for Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of releases for a specified project. Requires a valid projectId.

```java
// Get a list of releases for the specified project
List<Release> releases = gitLabApi.getReleasesApi().getReleases(projectId);
```

--------------------------------

### Get Pipelines for Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves all pipelines for a specified project ID. Requires a valid projectId.

```java
// Get all pipelines for the specified project ID
List<Pipeline> pipelines = gitLabApi.getPipelineApi().getPipelines(1234);
```

--------------------------------

### Get Commits within a Time Window with gitlab4j-api

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This example demonstrates retrieving a list of commits for a given project and branch within a specified time frame using the CommitsApi. It leverages ISO8601 date utilities for date handling. Dependencies include gitlab4j-api, Date, and ISO8601.

```java
// Get a list of commits associated with the specified branch that fall within the specified time window
// This uses the ISO8601 date utilities the in org.gitlab4j.api.utils.ISO8601 class
Date since = ISO8601.toDate("2017-01-01T00:00:00Z");
Date until = new Date(); // now
List<Commit> commits = gitLabApi.getCommitsApi().getCommits(1234, "new-feature", since, until);
```

--------------------------------

### Get Packages for Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves all packages associated with a specified project ID. Requires a valid projectId.

```java
// Get all packages for the specified project ID
List<Packages> packages = gitLabApi.getPackagesApi().getPackages(1234);
```

--------------------------------

### Get Accessible Projects

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of projects that the authenticated user has access to. This method does not require any parameters.

```java
// Get a list of accessible projects 
public List<Project> projects = gitLabApi.getProjectApi().getProjects();
```

--------------------------------

### Create New User with Reset Email (Java)

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This code creates a new user account. It allows specifying user details like email, name, and username. Crucially, it can be configured to send a password reset email to the new user, which is useful for initial account setup. The `password` parameter can be set to `null` to trigger the email.

```java
User userConfig = new User()
    .withEmail("jdoe@example.com")
    .withName("Jane Doe")
    .withUsername("jdoe");
String password = null;
boolean sendResetPasswordEmail = true;
gitLabApi.getUserApi().createUser(userConfig, password, sendResetPasswordEmail);
```

--------------------------------

### Get Container Registry Repositories with gitlab4j-api

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This snippet shows how to retrieve a list of registry repositories for a specified project using the ContainerRegistryApi. The projectId is a required input. The output is a list of RegistryRepository objects.

```java
// Get a list of the registry repositories belonging to the specified project
List<RegistryRepository> registryRepos = gitLabApi.ContainerRegistryApi().getRepositories(projectId);
```

--------------------------------

### Get License Information

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves information about the current GitLab license. This method does not require any parameters.

```java
// Retrieve information about the current license
License license = gitLabApi.getLicenseApi().getLicense();
```

--------------------------------

### Get All Runners

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of all available runners. This method does not require any parameters.

```java
// Get All Runners.
List<Runner> runners = gitLabApi.getRunnersApi().getAllRunners();
```

--------------------------------

### Get Labels for Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of labels for a specified project ID. Requires a valid projectId.

```java
// Get a list of labels for the specified project ID
List<Label> labels = gitLabApi.getLabelsApi().getLabels(1234);
```

--------------------------------

### Get Milestones for Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of milestones for a specified project. Requires a valid projectId.

```java
// Get a list of the milestones for the specified project
List<Milestone> milestones = gitLabApi.getMilestonesApi().getMilestones(1234);
```

--------------------------------

### Pipeline API

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

This API allows you to trigger, monitor, and control GitLab CI/CD pipelines and pipeline schedules. You can retrieve lists of pipelines, filter them by various criteria, get details of specific pipelines, create new pipelines, retry or cancel running ones, and access pipeline variables and test reports.

```APIDOC
## Pipeline API - Manage CI/CD Pipelines

Trigger, monitor, and control GitLab CI/CD pipelines and pipeline schedules.

### Get All Pipelines

- **Method**: GET
- **Endpoint**: `/projects/{id}/pipelines`
- **Description**: Retrieves a list of all pipelines for a project.
- **Query Parameters**:
  - `scope` (string) - Optional - Scope of pipelines to show (e.g., `all`, `running`, `pending`, `failed`, `canceled`).

### Filter Pipelines

- **Method**: GET
- **Endpoint**: `/projects/{id}/pipelines`
- **Description**: Retrieves a list of pipelines filtered by various criteria.
- **Query Parameters**:
  - `ref` (string) - Optional - Get pipelines for a specific branch or tag.
  - `status` (string) - Optional - Filter by pipeline status (e.g., `success`, `failed`, `running`).
  - `username` (string) - Optional - Get pipelines created by a specific user.
  - `yaml_errors` (boolean) - Optional - Include pipelines with YAML errors.
  - `order_by` (string) - Optional - Order pipelines by `id` or `status`. Defaults to `id`.
  - `sort` (string) - Optional - Sort order, `asc` or `desc`. Defaults to `desc`.

### Get a Specific Pipeline

- **Method**: GET
- **Endpoint**: `/projects/{id}/pipelines/{pipelineId}`
- **Description**: Retrieves details of a specific pipeline.
- **Path Parameters**:
  - `pipelineId` (integer) - Required - The ID of the pipeline.

### Create a New Pipeline

- **Method**: POST
- **Endpoint**: `/projects/{id}/pipelines`
- **Description**: Creates a new pipeline for a specific ref, optionally with variables.
- **Request Body**:
  - `ref` (string) - Required - The branch or tag to create the pipeline for.
  - `variables` (object) - Optional - A map of key-value pairs for pipeline variables.

### Retry Pipeline Jobs

- **Method**: POST
- **Endpoint**: `/projects/{id}/pipelines/{pipelineId}/retry`
- **Description**: Retries jobs for a specified pipeline that failed.
- **Path Parameters**:
  - `pipelineId` (integer) - Required - The ID of the pipeline.

### Cancel Pipeline Jobs

- **Method**: POST
- **Endpoint**: `/projects/{id}/pipelines/{pipelineId}/cancel`
- **Description**: Cancels jobs for a specified running pipeline.
- **Path Parameters**:
  - `pipelineId` (integer) - Required - The ID of the pipeline.

### Delete a Pipeline

- **Method**: DELETE
- **Endpoint**: `/projects/{id}/pipelines/{pipelineId}`
- **Description**: Deletes a pipeline.
- **Path Parameters**:
  - `pipelineId` (integer) - Required - The ID of the pipeline.

### Get Pipeline Test Report Summary

- **Method**: GET
- **Endpoint**: `/projects/{id}/pipelines/{pipelineId}/test_report`
- **Description**: Retrieves the test report summary for a pipeline.
- **Path Parameters**:
  - `pipelineId` (integer) - Required - The ID of the pipeline.

### Get Pipeline Variables

- **Method**: GET
- **Endpoint**: `/projects/{id}/pipelines/{pipelineId}/variables`
- **Description**: Retrieves the variables for a specific pipeline.
- **Path Parameters**:
  - `pipelineId` (integer) - Required - The ID of the pipeline.

```

--------------------------------

### Get Repository File

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves information (name, size, etc.) and content of a file within a repository. Requires file path, projectId, and ref (branch/tag).

```java
// Get info (name, size, ...) and the content from a file in repository
RepositoryFile file = gitLabApi.getRepositoryFileApi().getFile("file-path", 1234, "ref");   
```

--------------------------------

### Repository API

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

This API allows you to browse branches, tags, commits, and files in GitLab repositories. It provides methods to retrieve, create, and delete branches, get repository tree structure, compare branches, list contributors, and download archives.

```APIDOC
## Repository API - Access Repository Content

Browse branches, tags, commits, and files in GitLab repositories.

### Get All Branches

- **Method**: GET
- **Endpoint**: `/projects/{id}/repository/branches`
- **Description**: Retrieves a list of all branches for a project.
- **Query Parameters**:
  - `search` (string) - Optional - Search by branch name.

### Get a Specific Branch

- **Method**: GET
- **Endpoint**: `/projects/{id}/repository/branches/{branch}`
- **Description**: Retrieves a specific branch by its name.
- **Path Parameters**:
  - `branch` (string) - Required - The name of the branch.

### Create a New Branch

- **Method**: POST
- **Endpoint**: `/projects/{id}/repository/branches`
- **Description**: Creates a new branch from a specific ref.
- **Request Body**:
  - `branch` (string) - Required - The name of the new branch.
  - `ref` (string) - Required - The name of the branch or commit to create the new branch from.

### Delete a Branch

- **Method**: DELETE
- **Endpoint**: `/projects/{id}/repository/branches/{branch}`
- **Description**: Deletes a branch.
- **Path Parameters**:
  - `branch` (string) - Required - The name of the branch to delete.

### Get Repository Tree

- **Method**: GET
- **Endpoint**: `/projects/{id}/repository/tree`
- **Description**: Retrieves the repository tree (files and folders) at a specified path and ref.
- **Query Parameters**:
  - `path` (string) - Optional - The path of the directory to list.
  - `ref` (string) - Optional - The name of the repository branch or tag.
  - `recursive` (boolean) - Optional - Set to true to recursively list sub-directories.

### Compare Branches

- **Method**: GET
- **Endpoint**: `/projects/{id}/repository/compare`
- **Description**: Compares two branches or commits.
- **Query Parameters**:
  - `from` (string) - Required - The starting ref (branch or commit SHA).
  - `to` (string) - Required - The ending ref (branch or commit SHA).

### Get Contributors

- **Method**: GET
- **Endpoint**: `/projects/{id}/repository/contributors`
- **Description**: Retrieves a list of contributors for the repository.

### Download Repository Archive

- **Method**: GET
- **Endpoint**: `/projects/{id}/repository/archive`
- **Description**: Downloads the repository archive.
- **Query Parameters**:
  - `sha` (string) - Optional - The SHA of a commit or branch to archive.
  - `format` (string) - Optional - The archive format (`zip` or `tar.gz`). Defaults to `tar.gz`.

```

--------------------------------

### Get Jobs for Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of jobs for a specified project ID. Requires a valid projectId.

```java
// Get a list of jobs for the specified project ID
List<Job> jobs = gitLabApi.getJobApi().getJobs(1234);
```

--------------------------------

### Get Project Wiki Pages (Java)

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This snippet retrieves a list of all wiki pages within a project. It's useful for accessing and managing project documentation stored in GitLab wikis. The result is a List of WikiPage objects.

```java
List<WikiPage> wikiPages = gitLabApi.getWikisApi().getPages();
```

--------------------------------

### Java 8 Optional Support in GitLab4J-API

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Shows how to use Java 8 Optional<T> with GitLab4J-API calls that are expected to return a single item. This example demonstrates retrieving an optional group and handling cases where the group may or may not exist.

```java
import org.gitlab4j.api.GitLabApi;
import org.gitlab4j.api.models.Group;
import java.util.Optional;

GitLabApi gitlabApi = new GitLabApi("your_gitlab_url", "your_private_token");

// Retrieve an optional group
Optional<Group> optionalGroup =  gitlabApi.getGroupApi().getOptionalGroup("my-group-path");

// Handle the optional group
if (optionalGroup.isPresent()) {
    // Group exists, return it
    // return optionalGroup.get(); 
} 

// If group is not present, add a new one (example)
// return gitlabApi.getGroupApi().addGroup("my-group-name", "my-group-path");
```

--------------------------------

### Get Boards for a Project with gitlab4j-api

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This snippet shows how to fetch a list of Issue Boards belonging to a specific project using the BoardsApi. The projectId is required as input. The output is a list of Board objects.

```java
// Get a list of the Issue Boards belonging to the specified project
List<Board> boards = gitLabApi.getBoardsApi().getBoards(projectId);
```

--------------------------------

### GitLab API Initialization

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

Demonstrates how to initialize the GitLabApi client using personal access tokens, OAuth2, or with proxy configurations, and includes settings for timeouts and logging.

```APIDOC
## GitLab API Initialization

### Description
Initialize the `GitLabApi` client to connect to your GitLab server. This can be done using a personal access token, OAuth2 credentials, or by configuring proxy settings. You can also set request timeouts, enable request/response logging, and use the `sudo` functionality to perform actions as another user.

### Method
Initialization is done via static methods or constructors of the `GitLabApi` class.

### Endpoint
N/A (Client initialization)

### Parameters

#### Initialization with Personal Access Token
- **gitlabUrl** (String) - Required - The base URL of your GitLab instance.
- **privateToken** (String) - Required - Your GitLab personal access token.

#### Initialization with OAuth2
- **gitlabUrl** (String) - Required - The base URL of your GitLab instance.
- **username** (String) - Required - Your GitLab username.
- **password** (String) - Required - Your GitLab password.

#### Initialization with Proxy Configuration
- **gitlabUrl** (String) - Required - The base URL of your GitLab instance.
- **privateToken** (String) - Required - Your GitLab personal access token.
- **proxyConfig** (Map<String, Object>) - Optional - A map containing proxy configuration details.

#### Request Body
N/A

### Request Example
```java
import org.gitlab4j.api.GitLabApi;
import java.util.Map;

// Basic initialization with personal access token
GitLabApi gitLabApi = new GitLabApi("https://gitlab.example.com", "your-personal-access-token");

// With OAuth2 login
// GitLabApi gitLabApi = GitLabApi.oauth2Login("https://gitlab.example.com", "username", "password");

// With proxy configuration
// Map<String, Object> proxyConfig = ProxyClientConfig.createProxyClientConfig(
//     "http://proxy.example.com:8080",
//     "proxy-username",
//     "proxy-password"
// );
// GitLabApi gitLabApi = new GitLabApi("https://gitlab.example.com", "your-token", null, proxyConfig);

// Set request timeouts (connect: 1s, read: 5s)
gitLabApi.setRequestTimeout(1000, 5000);

// Enable request/response logging
gitLabApi.enableRequestResponseLogging(java.util.logging.Level.INFO, 1024);

// Perform actions as another user (requires admin privileges)
gitLabApi.sudo("johndoe");
// ... perform operations as johndoe
gitLabApi.unsudo();

// Clean up resources when done
// gitLabApi.close();
```

### Response

#### Success Response (Initialization)
An initialized `GitLabApi` object is returned.

#### Response Example
N/A (Object instantiation)
```

--------------------------------

### Initialize GitLab API Client

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

Demonstrates various ways to initialize the GitLabApi client, including using a personal access token, OAuth2 login, proxy configuration, setting timeouts, enabling logging, performing actions as another user (sudo), and closing the client.

```java
import org.gitlab4j.api.GitLabApi;
import java.util.Map;
import org.gitlab4j.api.ProxyClientConfig;

// Basic initialization with personal access token
GitLabApi gitLabApi = new GitLabApi("https://gitlab.example.com", "your-personal-access-token");

// With OAuth2 login
// GitLabApi gitLabApi = GitLabApi.oauth2Login("https://gitlab.example.com", "username", "password");

// With proxy configuration
Map<String, Object> proxyConfig = ProxyClientConfig.createProxyClientConfig(
    "http://proxy.example.com:8080",
    "proxy-username",
    "proxy-password"
);
// GitLabApi gitLabApi = new GitLabApi("https://gitlab.example.com", "your-token", null, proxyConfig);

// Set request timeouts (connect: 1s, read: 5s)
gitLabApi.setRequestTimeout(1000, 5000);

// Enable request/response logging
gitLabApi.enableRequestResponseLogging(java.util.logging.Level.INFO, 1024);

// Perform actions as another user (requires admin privileges)
gitLabApi.sudo("johndoe");
// ... perform operations as johndoe
gitLabApi.unsudo();

// Clean up resources when done
gitLabApi.close();
```

--------------------------------

### Create Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Creates a new project with specified details such as name, description, and enabled features. Requires a Project object with desired configurations.

```java
// Create a new project
Project projectSpec = new Project()
    .withName("my-project")
    .withDescription("My project for demonstration.")
    .withIssuesEnabled(true)
    .withMergeRequestsEnabled(true)
    .withWikiEnabled(true)
    .withSnippetsEnabled(true)
    .withPublic(true);

Project newProject = gitLabApi.getProjectApi().createProject(projectSpec);
```

--------------------------------

### Get Award Emojis for an Issue with gitlab4j-api

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This example demonstrates how to retrieve a list of AwardEmoji objects associated with a specific issue identified by its group ID and internal ID (IID) using the AwardEmojiApi. It requires the group ID and issue IID as input.

```java
// Get a list of AwardEmoji belonging to the specified issue (group ID = 1, issues IID = 1)
List<AwardEmoji> awardEmojis = gitLabApi.getAwardEmojiApi().getIssuAwardEmojis(1, 1);
```

--------------------------------

### Advanced Paging and Streaming with gitlab4j-api

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

This Java snippet demonstrates advanced techniques for handling large datasets from GitLab using the gitlab4j-api. It covers manual pagination with Pager, loading all items at once, and using Java 8 streams for both eager (pre-fetched) and lazy (on-demand) data retrieval. It also shows how to use Optional for single-item results and provide fallbacks.

```java
import org.gitlab4j.api.Pager;
import java.util.stream.Stream;
import static java.util.stream.Collectors.toList;
import static java.util.Comparator.comparing;

// Manual pagination with Pager
Pager<Project> projectPager = gitLabApi.getProjectApi().getProjects(10);
while (projectPager.hasNext()) {
    List<Project> page = projectPager.next();
    for (Project project : page) {
        System.out.println(project.getName() + " - " + project.getDescription());
    }
}

// Load all items at once from pager
Pager<Project> pager = gitLabApi.getProjectApi().getProjects(100);
List<Project> allProjects = pager.all();

// Eager stream (pre-fetches all data)
Stream<Project> projectStream = gitLabApi.getProjectApi().getProjectsStream();
List<String> projectNames = projectStream
    .map(Project::getName)
    .collect(toList());

// Parallel processing with eager streams
Stream<User> userStream = gitLabApi.getUserApi().getUsersStream();
List<User> sortedUsers = userStream
    .parallel()
    .sorted(comparing(User::getUsername))
    .collect(toList());

// Lazy stream (fetches pages on demand)
Pager<Issue> issuePager = gitLabApi.getIssuesApi().getIssues(1234L, 10);
issuePager.lazyStream()
    .filter(issue -> issue.getLabels().contains("bug"))
    .limit(5)
    .forEach(issue -> System.out.println(issue.getTitle()));

// Using Optional for single-item results
Optional<Project> optionalProject = gitLabApi.getProjectApi()
    .getOptionalProject("my-group/my-project");

if (optionalProject.isPresent()) {
    Project project = optionalProject.get();
    System.out.println("Found: " + project.getName());
} else {
    System.out.println("Project not found");
}

// Optional with fallback
Project project = gitLabApi.getProjectApi()
    .getOptionalProject("my-project")
    .orElseGet(() -> {
        try {
            Project newProj = new Project().withName("my-project");
            return gitLabApi.getProjectApi().createProject(newProj);
        } catch (GitLabApiException e) {
            throw new RuntimeException(e);
        }
    });

```

--------------------------------

### ProjectApi - Manage Projects

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

Provides methods for managing GitLab projects, including retrieving lists of projects, fetching individual projects by ID or path, creating new projects, updating project settings, and deleting projects.

```APIDOC
## ProjectApi - Manage Projects

### Description
This API allows you to access and manipulate GitLab projects. You can retrieve all accessible projects, paginate through project lists, get a specific project by its ID or URL-encoded path, create new projects with various settings, update existing project configurations, retrieve project statistics, and delete projects.

### Method
GET, POST, PUT, DELETE (depending on the operation)

### Endpoint
Various endpoints under `/projects`.

### Parameters

#### Get Projects (List)
- **pageSize** (Integer) - Optional - The number of projects to return per page.

#### Get Project by Path/ID
- **projectIdOrPath** (String or Long) - Required - The URL-encoded path or the ID of the project.

#### Create Project
- **project** (Project) - Required - A `Project` object containing the details for the new project.
  - **name** (String) - Required - The name of the project.
  - **description** (String) - Optional - The description of the project.
  - **issuesEnabled** (Boolean) - Optional - Whether issues are enabled for the project.
  - **mergeRequestsEnabled** (Boolean) - Optional - Whether merge requests are enabled for the project.
  - **wikiEnabled** (Boolean) - Optional - Whether the wiki is enabled for the project.
  - **snippetsEnabled** (Boolean) - Optional - Whether snippets are enabled for the project.
  - **visibility** (Visibility) - Optional - The visibility level of the project (e.g., `Visibility.PRIVATE`).

#### Update Project
- **project** (Project) - Required - A `Project` object with the updated details. Must include the project ID.

#### Get Project Statistics
- **projectIdOrPath** (String or Long) - Required - The ID or path of the project.

#### Delete Project
- **projectIdOrPath** (String or Long) - Required - The ID or path of the project.

### Request Example
```java
import org.gitlab4j.api.GitLabApi;
import org.gitlab4j.api.ProjectApi;
import org.gitlab4j.api.models.Project;
import org.gitlab4j.api.models.ProjectFilter;
import org.gitlab4j.api.Pager;
import org.gitlab4j.api.models.Visibility;
import java.util.List;

GitLabApi gitLabApi = new GitLabApi("https://gitlab.example.com", "your-personal-access-token");
ProjectApi projectApi = gitLabApi.getProjectApi();

// Get all accessible projects
// List<Project> projects = projectApi.getProjects();

// Get projects with pagination
// Pager<Project> pager = projectApi.getProjects(50); // 50 items per page
// while (pager.hasNext()) {
//     List<Project> page = pager.next();
//     for (Project project : page) {
//         System.out.println(project.getName() + ": " + project.getWebUrl());
//     }
// }

// Get a specific project by ID or path
// Project project = projectApi.getProject("my-group/my-project");
// Project projectById = projectApi.getProject(1234L);

// Create a new project
// Project newProject = new Project()
//     .withName("my-new-project")
//     .withDescription("A demonstration project")
//     .withIssuesEnabled(true)
//     .withMergeRequestsEnabled(true)
//     .withWikiEnabled(true)
//     .withSnippetsEnabled(true)
//     .withVisibility(Visibility.PRIVATE);
// Project created = projectApi.createProject(newProject);

// Update project settings
// Project existingProject = projectApi.getProject(1234L);
// existingProject.setDescription("Updated description");
// Project updated = projectApi.updateProject(existingProject);

// Get project statistics
// ProjectFetches stats = projectApi.getProjectStatistics(1234L);
// System.out.println("Total fetches: " + stats.getFetches().getTotal());

// Delete a project
// projectApi.deleteProject(1234L);
```

### Response

#### Success Response (Examples)
- **getProjects()**: `List<Project>`
- **getProject(id/path)**: `Project`
- **createProject(project)**: `Project` (the created project)
- **updateProject(project)**: `Project` (the updated project)
- **getProjectStatistics(id/path)**: `ProjectFetches`

#### Response Example (Project Object)
```json
{
  "id": 1234,
  "description": "A demonstration project",
  "name": "my-new-project",
  "created_at": "2023-10-27T10:00:00.000Z",
  "web_url": "https://gitlab.example.com/my-group/my-new-project",
  "visibility": "private"
}
```
```

--------------------------------

### Manage GitLab CI/CD Pipelines using Java

Source: https://context7.com/gitlab4j/gitlab4j-api/llms.txt

This snippet illustrates how to manage GitLab CI/CD pipelines using the PipelineApi in gitlab4j-api. It covers retrieving, filtering, creating, retrying, canceling, and deleting pipelines, as well as accessing pipeline variables and test reports. Requires a GitLabApi instance and project ID.

```java
import org.gitlab4j.api.PipelineApi;
import org.gitlab4j.api.models.Pipeline;
import org.gitlab4j.api.models.PipelineFilter;
import org.gitlab4j.api.models.PipelineStatus;
import org.gitlab4j.api.models.Variable;
import org.gitlab4j.api.models.TestReportSummary;

PipelineApi pipelineApi = gitLabApi.getPipelineApi();

// Get all pipelines for a project
List<Pipeline> pipelines = pipelineApi.getPipelines(1234L);

// Filter pipelines by status and ref
PipelineFilter filter = new PipelineFilter()
    .withStatus(PipelineStatus.SUCCESS)
    .withRef("main")
    .withUsername("john.doe");
List<Pipeline> filtered = pipelineApi.getPipelines(1234L, filter);

// Get a specific pipeline
Pipeline pipeline = pipelineApi.getPipeline(1234L, 567L);
System.out.println("Status: " + pipeline.getStatus());
System.out.println("Duration: " + pipeline.getDuration() + "s");

// Create a new pipeline
Map<String, Object> variables = new HashMap<>();
variables.put("DEPLOY_ENV", "staging");
Pipeline newPipeline = pipelineApi.createPipeline(1234L, "main", variables);

// Retry a failed pipeline
Pipeline retried = pipelineApi.retryPipelineJobs(1234L, 567L);

// Cancel a running pipeline
Pipeline cancelled = pipelineApi.cancelPipelineJobs(1234L, 567L);

// Delete a pipeline
pipelineApi.deletePipeline(1234L, 567L);

// Get pipeline test report summary
TestReportSummary testReport = pipelineApi.getTestReportSummary(1234L, 567L);
System.out.println("Total tests: " + testReport.getTotal().getCount());
System.out.println("Failed: " + testReport.getTotal().getFailed());
System.out.println("Success rate: " + testReport.getTotal().getSuccessRate() + "%");

// Get pipeline variables
List<Variable> vars = pipelineApi.getPipelineVariables(1234L, 567L);
vars.forEach(v -> System.out.println(v.getKey() + " = " + v.getValue()));
```

--------------------------------

### Get Protected Branches

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of protected branches for a given project ID. Requires a projectId.

```java
List<ProtectedBranch> branches = gitLabApi.getProtectedBranchesApi().getProtectedBranches(project.getId());
```

--------------------------------

### Initialize GitLabApi with API V3

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Creates a GitLabApi instance configured to use GitLab API Version 3. Note that GitLab server versions 11.0 and later have removed support for API v3. This option is provided for backward compatibility with older GitLab instances.

```java
// Create a GitLabApi instance to communicate with your GitLab server using GitLab API V3
GitLabApi gitLabApi = new GitLabApi(ApiVersion.V3, "http://your.gitlab.server.com", "YOUR_PRIVATE_TOKEN");
```

--------------------------------

### Configure Jitpack for Latest GitLab4J API with Gradle

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This snippet illustrates how to configure a Gradle project to use Jitpack for fetching the latest snapshot versions of the GitLab4J API. It involves adding Jitpack to the repositories and specifying the dependency with a 'main-SNAPSHOT' version.

```gradle
repositories {
    mavenCentral()
    maven {
        url "https://jitpack.io"
        content {
            includeGroup "com.github.gitlab4j.gitlab4j-api"
        }
    }
}

dependencies {
    // ...
    implementation 'com.github.gitlab4j.gitlab4j-api:gitlab4j-api:main-SNAPSHOT'
    // ...
}
```

--------------------------------

### Configure Jitpack for Latest GitLab4J API with Maven

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

This XML snippet shows how to set up a Maven project to use Jitpack for accessing the latest GitLab4J API versions. It adds the Jitpack repository and includes the dependency with the 'main-SNAPSHOT' version.

```xml
<repositories>
  <repository>
    <id>jitpack.io</id>
    <url>https://jitpack.io</url>
  </repository>
</repositories>

<dependencies>
  <dependency>
    <groupId>com.github.gitlab4j.gitlab4j-api</groupId>
    <artifactId>gitlab4j-api</artifactId>
    <version>main-SNAPSHOT</version>
  </dependency>
  <!-- ... -->
</dependencies>
```

--------------------------------

### Get Issues for Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of issues for a specified project ID. Requires a valid projectId.

```java
// Get a list of issues for the specified project ID
List<Issue> issues = gitLabApi.getIssuesApi().getIssues(1234);
```

--------------------------------

### Get Accessible Groups

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of groups that the authenticated user has access to. This method does not require any parameters.

```java
// Get a list of groups that you have access to
List<Group> groups = gitLabApi.getGroupApi().getGroups();
```

--------------------------------

### Initialize GitLabApi with Personal Access Token

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Instantiates the GitLabApi object for communication with a GitLab server using a personal access token. This is the primary method for authenticated API access. It requires the GitLab server URL and the user's personal access token.

```java
GitLabApi gitLabApi = new GitLabApi("http://your.gitlab.server.com", "YOUR_PERSONAL_ACCESS_TOKEN");

// Get the list of projects your account has access to
List<Project> projects = gitLabApi.getProjectApi().getProjects();
```

--------------------------------

### Namespace API

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Find namespaces by name or path.

```APIDOC
## GET /api/v4/namespaces

### Description
Get all namespaces that match the given query parameters.

### Method
GET

### Endpoint
/api/v4/namespaces

### Parameters
#### Query Parameters
- **search** (string) - Required - The search query string to match against namespace names or paths.

### Request Example
(No request body needed for GET request)

### Response
#### Success Response (200)
- **namespaces** (array) - List of Namespace objects.

#### Response Example
```json
[
  {
    "id": 1,
    "name": "foobar-group",
    "path": "foobar-group"
  }
]
```
```

--------------------------------

### Get Branches for Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of repository branches from a project, sorted alphabetically by name. Requires a projectId.

```java
// Get a list of repository branches from a project, sorted by name alphabetically
List<Branch> branches = gitLabApi.getRepositoryApi().getBranches(projectId);
```

--------------------------------

### Get Global Notification Settings

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves the current global notification settings for the user. This method does not require any parameters.

```java
// Get the current global notification settings
NotificationSettings settings = gitLabApi.getNotificationSettingsApi().getGlobalNotificationSettings();
```

--------------------------------

### Packages API

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieve all packages for a specified project.

```APIDOC
## GET /api/v4/projects/:id/packages

### Description
Get all packages for the specified project ID.

### Method
GET

### Endpoint
/api/v4/projects/:id/packages

### Parameters
#### Path Parameters
- **id** (integer) - Required - The ID of the project.

### Request Example
(No request body needed for GET request)

### Response
#### Success Response (200)
- **packages** (array) - List of Package objects.

#### Response Example
```json
[
  {
    "id": 1,
    "name": "my-package",
    "version": "1.0.0"
  }
]
```
```

--------------------------------

### Get Merge Requests for Project

Source: https://github.com/gitlab4j/gitlab4j-api/blob/main/README.md

Retrieves a list of merge requests for a specified project. Requires a valid projectId.

```java
// Get a list of the merge requests for the specified project
List<MergeRequest> mergeRequests = gitLabApi.getMergeRequestApi().getMergeRequests(1234);
```