defmodule GitHub.Codespaces do
@moduledoc """
Provides API endpoints related to codespaces
"""
@default_client GitHub.Client
@doc """
Add a selected repository to a user secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#add-a-selected-repository-to-a-user-secret)
"""
@spec add_repository_for_secret_for_authenticated_user(String.t(), integer, keyword) ::
:ok | {:error, GitHub.Error.t()}
def add_repository_for_secret_for_authenticated_user(secret_name, repository_id, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [secret_name: secret_name, repository_id: repository_id],
call: {GitHub.Codespaces, :add_repository_for_secret_for_authenticated_user},
url: "/user/codespaces/secrets/#{secret_name}/repositories/#{repository_id}",
method: :put,
response: [
{204, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Add selected repository to an organization secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#add-selected-repository-to-an-organization-secret)
"""
@spec add_selected_repo_to_org_secret(String.t(), String.t(), integer, keyword) ::
:ok | {:error, GitHub.Error.t()}
def add_selected_repo_to_org_secret(org, secret_name, repository_id, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, secret_name: secret_name, repository_id: repository_id],
call: {GitHub.Codespaces, :add_selected_repo_to_org_secret},
url: "/orgs/#{org}/codespaces/secrets/#{secret_name}/repositories/#{repository_id}",
method: :put,
response: [
{204, nil},
{404, {GitHub.BasicError, :t}},
{409, nil},
{422, {GitHub.ValidationError, :t}}
],
opts: opts
})
end
@doc """
List machine types for a codespace
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-machine-types-for-a-codespace)
"""
@spec codespace_machines_for_authenticated_user(String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def codespace_machines_for_authenticated_user(codespace_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [codespace_name: codespace_name],
call: {GitHub.Codespaces, :codespace_machines_for_authenticated_user},
url: "/user/codespaces/#{codespace_name}/machines",
method: :get,
response: [
{200, :map},
{304, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Create a codespace for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#create-a-codespace-for-the-authenticated-user)
"""
@spec create_for_authenticated_user(map, keyword) ::
{:ok, GitHub.Codespace.t()} | {:error, GitHub.Error.t()}
def create_for_authenticated_user(body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [body: body],
call: {GitHub.Codespaces, :create_for_authenticated_user},
url: "/user/codespaces",
body: body,
method: :post,
request: [{"application/json", :map}],
response: [
{201, {GitHub.Codespace, :t}},
{202, {GitHub.Codespace, :t}},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{503, :map}
],
opts: opts
})
end
@doc """
Create or update an organization secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#create-or-update-an-organization-secret)
"""
@spec create_or_update_org_secret(String.t(), String.t(), map, keyword) ::
{:ok, GitHub.EmptyObject.t()} | {:error, GitHub.Error.t()}
def create_or_update_org_secret(org, secret_name, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, secret_name: secret_name, body: body],
call: {GitHub.Codespaces, :create_or_update_org_secret},
url: "/orgs/#{org}/codespaces/secrets/#{secret_name}",
body: body,
method: :put,
request: [{"application/json", :map}],
response: [
{201, {GitHub.EmptyObject, :t}},
{204, nil},
{404, {GitHub.BasicError, :t}},
{422, {GitHub.ValidationError, :t}}
],
opts: opts
})
end
@doc """
Create or update a repository secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#create-or-update-a-repository-secret)
"""
@spec create_or_update_repo_secret(String.t(), String.t(), String.t(), map, keyword) ::
{:ok, GitHub.EmptyObject.t()} | {:error, GitHub.Error.t()}
def create_or_update_repo_secret(owner, repo, secret_name, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [owner: owner, repo: repo, secret_name: secret_name, body: body],
call: {GitHub.Codespaces, :create_or_update_repo_secret},
url: "/repos/#{owner}/#{repo}/codespaces/secrets/#{secret_name}",
body: body,
method: :put,
request: [{"application/json", :map}],
response: [{201, {GitHub.EmptyObject, :t}}, {204, nil}],
opts: opts
})
end
@doc """
Create or update a secret for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#create-or-update-a-secret-for-the-authenticated-user)
"""
@spec create_or_update_secret_for_authenticated_user(String.t(), map, keyword) ::
{:ok, GitHub.EmptyObject.t()} | {:error, GitHub.Error.t()}
def create_or_update_secret_for_authenticated_user(secret_name, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [secret_name: secret_name, body: body],
call: {GitHub.Codespaces, :create_or_update_secret_for_authenticated_user},
url: "/user/codespaces/secrets/#{secret_name}",
body: body,
method: :put,
request: [{"application/json", :map}],
response: [
{201, {GitHub.EmptyObject, :t}},
{204, nil},
{404, {GitHub.BasicError, :t}},
{422, {GitHub.ValidationError, :t}}
],
opts: opts
})
end
@doc """
Create a codespace from a pull request
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#create-a-codespace-from-a-pull-request)
"""
@spec create_with_pr_for_authenticated_user(String.t(), String.t(), integer, map | nil, keyword) ::
{:ok, GitHub.Codespace.t()} | {:error, GitHub.Error.t()}
def create_with_pr_for_authenticated_user(owner, repo, pull_number, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [owner: owner, repo: repo, pull_number: pull_number, body: body],
call: {GitHub.Codespaces, :create_with_pr_for_authenticated_user},
url: "/repos/#{owner}/#{repo}/pulls/#{pull_number}/codespaces",
body: body,
method: :post,
request: [{"application/json", {:nullable, :map}}],
response: [
{201, {GitHub.Codespace, :t}},
{202, {GitHub.Codespace, :t}},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{503, :map}
],
opts: opts
})
end
@doc """
Create a codespace in a repository
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#create-a-codespace-in-a-repository)
"""
@spec create_with_repo_for_authenticated_user(String.t(), String.t(), map | nil, keyword) ::
{:ok, GitHub.Codespace.t()} | {:error, GitHub.Error.t()}
def create_with_repo_for_authenticated_user(owner, repo, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [owner: owner, repo: repo, body: body],
call: {GitHub.Codespaces, :create_with_repo_for_authenticated_user},
url: "/repos/#{owner}/#{repo}/codespaces",
body: body,
method: :post,
request: [{"application/json", {:nullable, :map}}],
response: [
{201, {GitHub.Codespace, :t}},
{202, {GitHub.Codespace, :t}},
{400, {GitHub.BasicError, :t}},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{503, :map}
],
opts: opts
})
end
@doc """
Removes users from Codespaces billing for an organization
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#delete-codespaces-billing-users)
"""
@spec delete_codespaces_billing_users(String.t(), map, keyword) ::
:ok | {:error, GitHub.Error.t()}
def delete_codespaces_billing_users(org, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, body: body],
call: {GitHub.Codespaces, :delete_codespaces_billing_users},
url: "/orgs/#{org}/codespaces/billing/selected_users",
body: body,
method: :delete,
request: [{"application/json", :map}],
response: [
{204, nil},
{304, nil},
{400, nil},
{404, {GitHub.BasicError, :t}},
{422, {GitHub.ValidationError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Delete a codespace for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#delete-a-codespace-for-the-authenticated-user)
"""
@spec delete_for_authenticated_user(String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def delete_for_authenticated_user(codespace_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [codespace_name: codespace_name],
call: {GitHub.Codespaces, :delete_for_authenticated_user},
url: "/user/codespaces/#{codespace_name}",
method: :delete,
response: [
{202, :map},
{304, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Delete a codespace from the organization
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces)
"""
@spec delete_from_organization(String.t(), String.t(), String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def delete_from_organization(org, username, codespace_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, username: username, codespace_name: codespace_name],
call: {GitHub.Codespaces, :delete_from_organization},
url: "/orgs/#{org}/members/#{username}/codespaces/#{codespace_name}",
method: :delete,
response: [
{202, :map},
{304, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Delete an organization secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#delete-an-organization-secret)
"""
@spec delete_org_secret(String.t(), String.t(), keyword) :: :ok | {:error, GitHub.Error.t()}
def delete_org_secret(org, secret_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, secret_name: secret_name],
call: {GitHub.Codespaces, :delete_org_secret},
url: "/orgs/#{org}/codespaces/secrets/#{secret_name}",
method: :delete,
response: [{204, nil}, {404, {GitHub.BasicError, :t}}],
opts: opts
})
end
@doc """
Delete a repository secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#delete-a-repository-secret)
"""
@spec delete_repo_secret(String.t(), String.t(), String.t(), keyword) ::
:ok | {:error, GitHub.Error.t()}
def delete_repo_secret(owner, repo, secret_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [owner: owner, repo: repo, secret_name: secret_name],
call: {GitHub.Codespaces, :delete_repo_secret},
url: "/repos/#{owner}/#{repo}/codespaces/secrets/#{secret_name}",
method: :delete,
response: [{204, nil}],
opts: opts
})
end
@doc """
Delete a secret for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#delete-a-secret-for-the-authenticated-user)
"""
@spec delete_secret_for_authenticated_user(String.t(), keyword) ::
:ok | {:error, GitHub.Error.t()}
def delete_secret_for_authenticated_user(secret_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [secret_name: secret_name],
call: {GitHub.Codespaces, :delete_secret_for_authenticated_user},
url: "/user/codespaces/secrets/#{secret_name}",
method: :delete,
response: [{204, nil}],
opts: opts
})
end
@doc """
Export a codespace for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/codespaces/codespaces#export-a-codespace-for-the-authenticated-user)
"""
@spec export_for_authenticated_user(String.t(), keyword) ::
{:ok, GitHub.Codespace.ExportDetails.t()} | {:error, GitHub.Error.t()}
def export_for_authenticated_user(codespace_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [codespace_name: codespace_name],
call: {GitHub.Codespaces, :export_for_authenticated_user},
url: "/user/codespaces/#{codespace_name}/exports",
method: :post,
response: [
{202, {GitHub.Codespace.ExportDetails, :t}},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{422, {GitHub.ValidationError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
List codespaces for a user in organization
## Options
* `per_page` (integer): The number of results per page (max 100).
* `page` (integer): Page number of the results to fetch.
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#get-codespaces-for-user-in-org)
"""
@spec get_codespaces_for_user_in_org(String.t(), String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def get_codespaces_for_user_in_org(org, username, opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:page, :per_page])
client.request(%{
args: [org: org, username: username],
call: {GitHub.Codespaces, :get_codespaces_for_user_in_org},
url: "/orgs/#{org}/members/#{username}/codespaces",
method: :get,
query: query,
response: [
{200, :map},
{304, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Get details about a codespace export
## Resources
* [API method documentation](https://docs.github.com/rest/codespaces/codespaces#get-details-about-a-codespace-export)
"""
@spec get_export_details_for_authenticated_user(String.t(), String.t(), keyword) ::
{:ok, GitHub.Codespace.ExportDetails.t()} | {:error, GitHub.Error.t()}
def get_export_details_for_authenticated_user(codespace_name, export_id, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [codespace_name: codespace_name, export_id: export_id],
call: {GitHub.Codespaces, :get_export_details_for_authenticated_user},
url: "/user/codespaces/#{codespace_name}/exports/#{export_id}",
method: :get,
response: [{200, {GitHub.Codespace.ExportDetails, :t}}, {404, {GitHub.BasicError, :t}}],
opts: opts
})
end
@doc """
Get a codespace for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#get-a-codespace-for-the-authenticated-user)
"""
@spec get_for_authenticated_user(String.t(), keyword) ::
{:ok, GitHub.Codespace.t()} | {:error, GitHub.Error.t()}
def get_for_authenticated_user(codespace_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [codespace_name: codespace_name],
call: {GitHub.Codespaces, :get_for_authenticated_user},
url: "/user/codespaces/#{codespace_name}",
method: :get,
response: [
{200, {GitHub.Codespace, :t}},
{304, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Get an organization public key
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#get-an-organization-public-key)
"""
@spec get_org_public_key(String.t(), keyword) ::
{:ok, GitHub.Codespace.PublicKey.t()} | {:error, GitHub.Error.t()}
def get_org_public_key(org, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org],
call: {GitHub.Codespaces, :get_org_public_key},
url: "/orgs/#{org}/codespaces/secrets/public-key",
method: :get,
response: [{200, {GitHub.Codespace.PublicKey, :t}}],
opts: opts
})
end
@doc """
Get an organization secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#get-an-organization-secret)
"""
@spec get_org_secret(String.t(), String.t(), keyword) ::
{:ok, GitHub.Codespace.OrgSecret.t()} | {:error, GitHub.Error.t()}
def get_org_secret(org, secret_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, secret_name: secret_name],
call: {GitHub.Codespaces, :get_org_secret},
url: "/orgs/#{org}/codespaces/secrets/#{secret_name}",
method: :get,
response: [{200, {GitHub.Codespace.OrgSecret, :t}}],
opts: opts
})
end
@doc """
Get public key for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#get-public-key-for-the-authenticated-user)
"""
@spec get_public_key_for_authenticated_user(keyword) ::
{:ok, GitHub.Codespace.UserPublicKey.t()} | {:error, GitHub.Error.t()}
def get_public_key_for_authenticated_user(opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
call: {GitHub.Codespaces, :get_public_key_for_authenticated_user},
url: "/user/codespaces/secrets/public-key",
method: :get,
response: [{200, {GitHub.Codespace.UserPublicKey, :t}}],
opts: opts
})
end
@doc """
Get a repository public key
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#get-a-repository-public-key)
"""
@spec get_repo_public_key(String.t(), String.t(), keyword) ::
{:ok, GitHub.Codespace.PublicKey.t()} | {:error, GitHub.Error.t()}
def get_repo_public_key(owner, repo, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [owner: owner, repo: repo],
call: {GitHub.Codespaces, :get_repo_public_key},
url: "/repos/#{owner}/#{repo}/codespaces/secrets/public-key",
method: :get,
response: [{200, {GitHub.Codespace.PublicKey, :t}}],
opts: opts
})
end
@doc """
Get a repository secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#get-a-repository-secret)
"""
@spec get_repo_secret(String.t(), String.t(), String.t(), keyword) ::
{:ok, GitHub.RepoCodespacesSecret.t()} | {:error, GitHub.Error.t()}
def get_repo_secret(owner, repo, secret_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [owner: owner, repo: repo, secret_name: secret_name],
call: {GitHub.Codespaces, :get_repo_secret},
url: "/repos/#{owner}/#{repo}/codespaces/secrets/#{secret_name}",
method: :get,
response: [{200, {GitHub.RepoCodespacesSecret, :t}}],
opts: opts
})
end
@doc """
Get a secret for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#get-a-secret-for-the-authenticated-user)
"""
@spec get_secret_for_authenticated_user(String.t(), keyword) ::
{:ok, GitHub.Codespace.Secret.t()} | {:error, GitHub.Error.t()}
def get_secret_for_authenticated_user(secret_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [secret_name: secret_name],
call: {GitHub.Codespaces, :get_secret_for_authenticated_user},
url: "/user/codespaces/secrets/#{secret_name}",
method: :get,
response: [{200, {GitHub.Codespace.Secret, :t}}],
opts: opts
})
end
@doc """
List devcontainer configurations in a repository for the authenticated user
## Options
* `per_page` (integer): The number of results per page (max 100).
* `page` (integer): Page number of the results to fetch.
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-devcontainers-in-a-repository-for-the-authenticated-user)
"""
@spec list_devcontainers_in_repository_for_authenticated_user(String.t(), String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def list_devcontainers_in_repository_for_authenticated_user(owner, repo, opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:page, :per_page])
client.request(%{
args: [owner: owner, repo: repo],
call: {GitHub.Codespaces, :list_devcontainers_in_repository_for_authenticated_user},
url: "/repos/#{owner}/#{repo}/codespaces/devcontainers",
method: :get,
query: query,
response: [
{200, :map},
{400, {GitHub.BasicError, :t}},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
List codespaces for the authenticated user
## Options
* `per_page` (integer): The number of results per page (max 100).
* `page` (integer): Page number of the results to fetch.
* `repository_id` (integer): ID of the Repository to filter on
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-codespaces-for-the-authenticated-user)
"""
@spec list_for_authenticated_user(keyword) :: {:ok, map} | {:error, GitHub.Error.t()}
def list_for_authenticated_user(opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:page, :per_page, :repository_id])
client.request(%{
call: {GitHub.Codespaces, :list_for_authenticated_user},
url: "/user/codespaces",
method: :get,
query: query,
response: [
{200, :map},
{304, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
List codespaces for the organization
## Options
* `per_page` (integer): The number of results per page (max 100).
* `page` (integer): Page number of the results to fetch.
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-in-organization)
"""
@spec list_in_organization(String.t(), keyword) :: {:ok, map} | {:error, GitHub.Error.t()}
def list_in_organization(org, opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:page, :per_page])
client.request(%{
args: [org: org],
call: {GitHub.Codespaces, :list_in_organization},
url: "/orgs/#{org}/codespaces",
method: :get,
query: query,
response: [
{200, :map},
{304, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
List codespaces in a repository for the authenticated user
## Options
* `per_page` (integer): The number of results per page (max 100).
* `page` (integer): Page number of the results to fetch.
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-codespaces-in-a-repository-for-the-authenticated-user)
"""
@spec list_in_repository_for_authenticated_user(String.t(), String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def list_in_repository_for_authenticated_user(owner, repo, opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:page, :per_page])
client.request(%{
args: [owner: owner, repo: repo],
call: {GitHub.Codespaces, :list_in_repository_for_authenticated_user},
url: "/repos/#{owner}/#{repo}/codespaces",
method: :get,
query: query,
response: [
{200, :map},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
List organization secrets
## Options
* `per_page` (integer): The number of results per page (max 100).
* `page` (integer): Page number of the results to fetch.
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-organization-secrets)
"""
@spec list_org_secrets(String.t(), keyword) :: {:ok, map} | {:error, GitHub.Error.t()}
def list_org_secrets(org, opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:page, :per_page])
client.request(%{
args: [org: org],
call: {GitHub.Codespaces, :list_org_secrets},
url: "/orgs/#{org}/codespaces/secrets",
method: :get,
query: query,
response: [{200, :map}],
opts: opts
})
end
@doc """
List repository secrets
## Options
* `per_page` (integer): The number of results per page (max 100).
* `page` (integer): Page number of the results to fetch.
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-repository-secrets)
"""
@spec list_repo_secrets(String.t(), String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def list_repo_secrets(owner, repo, opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:page, :per_page])
client.request(%{
args: [owner: owner, repo: repo],
call: {GitHub.Codespaces, :list_repo_secrets},
url: "/repos/#{owner}/#{repo}/codespaces/secrets",
method: :get,
query: query,
response: [{200, :map}],
opts: opts
})
end
@doc """
List selected repositories for a user secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-selected-repositories-for-a-user-secret)
"""
@spec list_repositories_for_secret_for_authenticated_user(String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def list_repositories_for_secret_for_authenticated_user(secret_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [secret_name: secret_name],
call: {GitHub.Codespaces, :list_repositories_for_secret_for_authenticated_user},
url: "/user/codespaces/secrets/#{secret_name}/repositories",
method: :get,
response: [
{200, :map},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
List secrets for the authenticated user
## Options
* `per_page` (integer): The number of results per page (max 100).
* `page` (integer): Page number of the results to fetch.
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-secrets-for-the-authenticated-user)
"""
@spec list_secrets_for_authenticated_user(keyword) :: {:ok, map} | {:error, GitHub.Error.t()}
def list_secrets_for_authenticated_user(opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:page, :per_page])
client.request(%{
call: {GitHub.Codespaces, :list_secrets_for_authenticated_user},
url: "/user/codespaces/secrets",
method: :get,
query: query,
response: [{200, :map}],
opts: opts
})
end
@doc """
List selected repositories for an organization secret
## Options
* `page` (integer): Page number of the results to fetch.
* `per_page` (integer): The number of results per page (max 100).
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-selected-repositories-for-an-organization-secret)
"""
@spec list_selected_repos_for_org_secret(String.t(), String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def list_selected_repos_for_org_secret(org, secret_name, opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:page, :per_page])
client.request(%{
args: [org: org, secret_name: secret_name],
call: {GitHub.Codespaces, :list_selected_repos_for_org_secret},
url: "/orgs/#{org}/codespaces/secrets/#{secret_name}/repositories",
method: :get,
query: query,
response: [{200, :map}, {404, {GitHub.BasicError, :t}}],
opts: opts
})
end
@doc """
Get default attributes for a codespace
## Options
* `ref` (String.t()): The branch or commit to check for a default devcontainer path. If not specified, the default branch will be checked.
* `client_ip` (String.t()): An alternative IP for default location auto-detection, such as when proxying a request.
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#preview-attributes-for-a-new-codespace)
"""
@spec pre_flight_with_repo_for_authenticated_user(String.t(), String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def pre_flight_with_repo_for_authenticated_user(owner, repo, opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:client_ip, :ref])
client.request(%{
args: [owner: owner, repo: repo],
call: {GitHub.Codespaces, :pre_flight_with_repo_for_authenticated_user},
url: "/repos/#{owner}/#{repo}/codespaces/new",
method: :get,
query: query,
response: [
{200, :map},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Create a repository from an unpublished codespace
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces/codespaces#create-a-repository-from-an-unpublished-codespace)
"""
@spec publish_for_authenticated_user(String.t(), map, keyword) ::
{:ok, GitHub.Codespace.WithFullRepository.t()} | {:error, GitHub.Error.t()}
def publish_for_authenticated_user(codespace_name, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [codespace_name: codespace_name, body: body],
call: {GitHub.Codespaces, :publish_for_authenticated_user},
url: "/user/codespaces/#{codespace_name}/publish",
body: body,
method: :post,
request: [{"application/json", :map}],
response: [
{201, {GitHub.Codespace.WithFullRepository, :t}},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{422, {GitHub.ValidationError, :t}}
],
opts: opts
})
end
@doc """
Remove a selected repository from a user secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#remove-a-selected-repository-from-a-user-secret)
"""
@spec remove_repository_for_secret_for_authenticated_user(String.t(), integer, keyword) ::
:ok | {:error, GitHub.Error.t()}
def remove_repository_for_secret_for_authenticated_user(secret_name, repository_id, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [secret_name: secret_name, repository_id: repository_id],
call: {GitHub.Codespaces, :remove_repository_for_secret_for_authenticated_user},
url: "/user/codespaces/secrets/#{secret_name}/repositories/#{repository_id}",
method: :delete,
response: [
{204, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Remove selected repository from an organization secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#remove-selected-repository-from-an-organization-secret)
"""
@spec remove_selected_repo_from_org_secret(String.t(), String.t(), integer, keyword) ::
:ok | {:error, GitHub.Error.t()}
def remove_selected_repo_from_org_secret(org, secret_name, repository_id, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, secret_name: secret_name, repository_id: repository_id],
call: {GitHub.Codespaces, :remove_selected_repo_from_org_secret},
url: "/orgs/#{org}/codespaces/secrets/#{secret_name}/repositories/#{repository_id}",
method: :delete,
response: [
{204, nil},
{404, {GitHub.BasicError, :t}},
{409, nil},
{422, {GitHub.ValidationError, :t}}
],
opts: opts
})
end
@doc """
List available machine types for a repository
## Options
* `location` (String.t()): The location to check for available machines. Assigned by IP if not provided.
* `client_ip` (String.t()): IP for location auto-detection when proxying a request
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#list-available-machine-types-for-a-repository)
"""
@spec repo_machines_for_authenticated_user(String.t(), String.t(), keyword) ::
{:ok, map} | {:error, GitHub.Error.t()}
def repo_machines_for_authenticated_user(owner, repo, opts \\ []) do
client = opts[:client] || @default_client
query = Keyword.take(opts, [:client_ip, :location])
client.request(%{
args: [owner: owner, repo: repo],
call: {GitHub.Codespaces, :repo_machines_for_authenticated_user},
url: "/repos/#{owner}/#{repo}/codespaces/machines",
method: :get,
query: query,
response: [
{200, :map},
{304, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Manage access control for organization codespaces
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#set-codespaces-billing)
"""
@spec set_codespaces_billing(String.t(), map, keyword) :: :ok | {:error, GitHub.Error.t()}
def set_codespaces_billing(org, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, body: body],
call: {GitHub.Codespaces, :set_codespaces_billing},
url: "/orgs/#{org}/codespaces/billing",
body: body,
method: :put,
request: [{"application/json", :map}],
response: [
{204, nil},
{304, nil},
{400, nil},
{404, {GitHub.BasicError, :t}},
{422, {GitHub.ValidationError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Add users to Codespaces billing for an organization
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#set-codespaces-billing-users)
"""
@spec set_codespaces_billing_users(String.t(), map, keyword) :: :ok | {:error, GitHub.Error.t()}
def set_codespaces_billing_users(org, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, body: body],
call: {GitHub.Codespaces, :set_codespaces_billing_users},
url: "/orgs/#{org}/codespaces/billing/selected_users",
body: body,
method: :post,
request: [{"application/json", :map}],
response: [
{204, nil},
{304, nil},
{400, nil},
{404, {GitHub.BasicError, :t}},
{422, {GitHub.ValidationError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Set selected repositories for a user secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#set-selected-repositories-for-a-user-secret)
"""
@spec set_repositories_for_secret_for_authenticated_user(String.t(), map, keyword) ::
:ok | {:error, GitHub.Error.t()}
def set_repositories_for_secret_for_authenticated_user(secret_name, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [secret_name: secret_name, body: body],
call: {GitHub.Codespaces, :set_repositories_for_secret_for_authenticated_user},
url: "/user/codespaces/secrets/#{secret_name}/repositories",
body: body,
method: :put,
request: [{"application/json", :map}],
response: [
{204, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Set selected repositories for an organization secret
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#set-selected-repositories-for-an-organization-secret)
"""
@spec set_selected_repos_for_org_secret(String.t(), String.t(), map, keyword) ::
:ok | {:error, GitHub.Error.t()}
def set_selected_repos_for_org_secret(org, secret_name, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, secret_name: secret_name, body: body],
call: {GitHub.Codespaces, :set_selected_repos_for_org_secret},
url: "/orgs/#{org}/codespaces/secrets/#{secret_name}/repositories",
body: body,
method: :put,
request: [{"application/json", :map}],
response: [{204, nil}, {404, {GitHub.BasicError, :t}}, {409, nil}],
opts: opts
})
end
@doc """
Start a codespace for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#start-a-codespace-for-the-authenticated-user)
"""
@spec start_for_authenticated_user(String.t(), keyword) ::
{:ok, GitHub.Codespace.t()} | {:error, GitHub.Error.t()}
def start_for_authenticated_user(codespace_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [codespace_name: codespace_name],
call: {GitHub.Codespaces, :start_for_authenticated_user},
url: "/user/codespaces/#{codespace_name}/start",
method: :post,
response: [
{200, {GitHub.Codespace, :t}},
{304, nil},
{400, {GitHub.BasicError, :t}},
{401, {GitHub.BasicError, :t}},
{402, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{409, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Stop a codespace for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#stop-a-codespace-for-the-authenticated-user)
"""
@spec stop_for_authenticated_user(String.t(), keyword) ::
{:ok, GitHub.Codespace.t()} | {:error, GitHub.Error.t()}
def stop_for_authenticated_user(codespace_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [codespace_name: codespace_name],
call: {GitHub.Codespaces, :stop_for_authenticated_user},
url: "/user/codespaces/#{codespace_name}/stop",
method: :post,
response: [
{200, {GitHub.Codespace, :t}},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Stop a codespace for an organization user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces)
"""
@spec stop_in_organization(String.t(), String.t(), String.t(), keyword) ::
{:ok, GitHub.Codespace.t()} | {:error, GitHub.Error.t()}
def stop_in_organization(org, username, codespace_name, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [org: org, username: username, codespace_name: codespace_name],
call: {GitHub.Codespaces, :stop_in_organization},
url: "/orgs/#{org}/members/#{username}/codespaces/#{codespace_name}/stop",
method: :post,
response: [
{200, {GitHub.Codespace, :t}},
{304, nil},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}},
{500, {GitHub.BasicError, :t}}
],
opts: opts
})
end
@doc """
Update a codespace for the authenticated user
## Resources
* [API method documentation](https://docs.github.com/rest/reference/codespaces#update-a-codespace-for-the-authenticated-user)
"""
@spec update_for_authenticated_user(String.t(), map, keyword) ::
{:ok, GitHub.Codespace.t()} | {:error, GitHub.Error.t()}
def update_for_authenticated_user(codespace_name, body, opts \\ []) do
client = opts[:client] || @default_client
client.request(%{
args: [codespace_name: codespace_name, body: body],
call: {GitHub.Codespaces, :update_for_authenticated_user},
url: "/user/codespaces/#{codespace_name}",
body: body,
method: :patch,
request: [{"application/json", :map}],
response: [
{200, {GitHub.Codespace, :t}},
{401, {GitHub.BasicError, :t}},
{403, {GitHub.BasicError, :t}},
{404, {GitHub.BasicError, :t}}
],
opts: opts
})
end
end
