aws-delivlib 14.4.2 → 14.4.3

package/lib/publishing/github/node_modules/@octokit/plugin-rest-endpoint-methods/dist-types/generated/method-types.d.ts

@@ -1,6 +1,6 @@
 import { EndpointInterface, RequestInterface } from "@octokit/types";
 import { RestEndpointMethodTypes } from "./parameters-and-response-types";
-export declare type RestEndpointMethods = {
+export type RestEndpointMethods = {
     actions: {
         /**
          * Add custom labels to a self-hosted runner configured in an organization.
@@ -37,6 +37,30 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Adds a repository to an organization variable that is available to selected repositories. Organization variables that are available to selected repositories have their `visibility` field set to `selected`. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `organization_actions_variables:write` organization permission to use this endpoint.
+         */
+        addSelectedRepoToOrgVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["addSelectedRepoToOrgVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["addSelectedRepoToOrgVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Adds a repository to a required workflow. To use this endpoint, the required workflow must be configured to run on selected repositories.
+         *
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         *
+         * For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        addSelectedRepoToRequiredWorkflow: {
+            (params?: RestEndpointMethodTypes["actions"]["addSelectedRepoToRequiredWorkflow"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["addSelectedRepoToRequiredWorkflow"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Approves a workflow run for a pull request from a public fork of a first time contributor. For more information, see ["Approving workflow runs from public forks](https://docs.github.com/actions/managing-workflow-runs/approving-workflow-runs-from-public-forks)."
          *
@@ -59,6 +83,18 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Create an environment variable that you can reference in a GitHub Actions workflow.
+         * You must authenticate using an access token with the `repo` scope to use this endpoint.
+         * GitHub Apps must have the `environment:write` repository permission to use this endpoint.
+         */
+        createEnvironmentVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["createEnvironmentVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["createEnvironmentVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Creates or updates an environment secret with an encrypted value. Encrypt your secret using
          * [LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages). You must authenticate using an access
@@ -67,28 +103,29 @@ export declare type RestEndpointMethods = {
          *
          * #### Example encrypting a secret using Node.js
          *
-         * Encrypt your secret using the [tweetsodium](https://github.com/github/tweetsodium) library.
+         * Encrypt your secret using the [libsodium-wrappers](https://www.npmjs.com/package/libsodium-wrappers) library.
          *
          * ```
-         * const sodium = require('tweetsodium');
-         *
-         * const key = "base64-encoded-public-key";
-         * const value = "plain-text-secret";
+         * const sodium = require('libsodium-wrappers')
+         * const secret = 'plain-text-secret' // replace with the secret you want to encrypt
+         * const key = 'base64-encoded-public-key' // replace with the Base64 encoded public key
          *
-         * // Convert the message and key to Uint8Array's (Buffer implements that interface)
-         * const messageBytes = Buffer.from(value);
-         * const keyBytes = Buffer.from(key, 'base64');
+         * //Check if libsodium is ready and then proceed.
+         * sodium.ready.then(() => {
+         *   // Convert Secret & Base64 key to Uint8Array.
+         *   let binkey = sodium.from_base64(key, sodium.base64_variants.ORIGINAL)
+         *   let binsec = sodium.from_string(secret)
          *
-         * // Encrypt using LibSodium.
-         * const encryptedBytes = sodium.seal(messageBytes, keyBytes);
+         *   //Encrypt the secret using LibSodium
+         *   let encBytes = sodium.crypto_box_seal(binsec, binkey)
          *
-         * // Base64 the encrypted secret
-         * const encrypted = Buffer.from(encryptedBytes).toString('base64');
+         *   // Convert encrypted Uint8Array to Base64
+         *   let output = sodium.to_base64(encBytes, sodium.base64_variants.ORIGINAL)
          *
-         * console.log(encrypted);
+         *   console.log(output)
+         * });
          * ```
          *
-         *
          * #### Example encrypting a secret using Python
          *
          * Encrypt your secret using [pynacl](https://pynacl.readthedocs.io/en/latest/public/#nacl-public-sealedbox) with Python 3.
@@ -235,28 +272,29 @@ export declare type RestEndpointMethods = {
          *
          * #### Example encrypting a secret using Node.js
          *
-         * Encrypt your secret using the [tweetsodium](https://github.com/github/tweetsodium) library.
+         * Encrypt your secret using the [libsodium-wrappers](https://www.npmjs.com/package/libsodium-wrappers) library.
          *
          * ```
-         * const sodium = require('tweetsodium');
-         *
-         * const key = "base64-encoded-public-key";
-         * const value = "plain-text-secret";
+         * const sodium = require('libsodium-wrappers')
+         * const secret = 'plain-text-secret' // replace with the secret you want to encrypt
+         * const key = 'base64-encoded-public-key' // replace with the Base64 encoded public key
          *
-         * // Convert the message and key to Uint8Array's (Buffer implements that interface)
-         * const messageBytes = Buffer.from(value);
-         * const keyBytes = Buffer.from(key, 'base64');
+         * //Check if libsodium is ready and then proceed.
+         * sodium.ready.then(() => {
+         *   // Convert Secret & Base64 key to Uint8Array.
+         *   let binkey = sodium.from_base64(key, sodium.base64_variants.ORIGINAL)
+         *   let binsec = sodium.from_string(secret)
          *
-         * // Encrypt using LibSodium.
-         * const encryptedBytes = sodium.seal(messageBytes, keyBytes);
+         *   //Encrypt the secret using LibSodium
+         *   let encBytes = sodium.crypto_box_seal(binsec, binkey)
          *
-         * // Base64 the encrypted secret
-         * const encrypted = Buffer.from(encryptedBytes).toString('base64');
+         *   // Convert encrypted Uint8Array to Base64
+         *   let output = sodium.to_base64(encBytes, sodium.base64_variants.ORIGINAL)
          *
-         * console.log(encrypted);
+         *   console.log(output)
+         * });
          * ```
          *
-         *
          * #### Example encrypting a secret using Python
          *
          * Encrypt your secret using [pynacl](https://pynacl.readthedocs.io/en/latest/public/#nacl-public-sealedbox) with Python 3.
@@ -311,6 +349,18 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Creates an organization variable that you can reference in a GitHub Actions workflow.
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         * GitHub Apps must have the `organization_actions_variables:write` organization permission to use this endpoint.
+         */
+        createOrgVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["createOrgVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["createOrgVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Returns a token that you can pass to the `config` script. The token expires after one hour.
          *
@@ -390,6 +440,32 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Creates a repository variable that you can reference in a GitHub Actions workflow.
+         * You must authenticate using an access token with the `repo` scope to use this endpoint.
+         * GitHub Apps must have the `actions_variables:write` repository permission to use this endpoint.
+         */
+        createRepoVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["createRepoVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["createRepoVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Create a required workflow in an organization.
+         *
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         *
+         * For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        createRequiredWorkflow: {
+            (params?: RestEndpointMethodTypes["actions"]["createRequiredWorkflow"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["createRequiredWorkflow"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * You can use this endpoint to manually trigger a GitHub Actions workflow run. You can replace `workflow_id` with the workflow file name. For example, you could use `main.yaml`.
          *
@@ -452,6 +528,18 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Deletes an environment variable using the variable name.
+         * You must authenticate using an access token with the `repo` scope to use this endpoint.
+         * GitHub Apps must have the `environment:write` repository permission to use this endpoint.
+         */
+        deleteEnvironmentVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["deleteEnvironmentVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["deleteEnvironmentVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Deletes a secret in an organization using the secret name. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `secrets` organization permission to use this endpoint.
          */
@@ -462,6 +550,18 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Deletes an organization variable using the variable name.
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         * GitHub Apps must have the `organization_actions_variables:write` organization permission to use this endpoint.
+         */
+        deleteOrgVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["deleteOrgVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["deleteOrgVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Deletes a secret in a repository using the secret name. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `secrets` repository permission to use this endpoint.
          */
@@ -472,6 +572,32 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Deletes a repository variable using the variable name.
+         * You must authenticate using an access token with the `repo` scope to use this endpoint.
+         * GitHub Apps must have the `actions_variables:write` repository permission to use this endpoint.
+         */
+        deleteRepoVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["deleteRepoVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["deleteRepoVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Deletes a required workflow configured in an organization.
+         *
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         *
+         * For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        deleteRequiredWorkflow: {
+            (params?: RestEndpointMethodTypes["actions"]["deleteRequiredWorkflow"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["deleteRequiredWorkflow"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Forces the removal of a self-hosted runner from an organization. You can use this endpoint to completely remove the runner when the machine you were using no longer exists.
          *
@@ -655,18 +781,6 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
-        /**
-         * Gets the total GitHub Actions cache usage for an enterprise.
-         * The data fetched using this API is refreshed approximately every 5 minutes, so values returned from this endpoint may take at least 5 minutes to get updated.
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
-         */
-        getActionsCacheUsageForEnterprise: {
-            (params?: RestEndpointMethodTypes["actions"]["getActionsCacheUsageForEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["getActionsCacheUsageForEnterprise"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
         /**
          * Gets the total GitHub Actions cache usage for an organization.
          * The data fetched using this API is refreshed approximately every 5 minutes, so values returned from this endpoint may take at least 5 minutes to get updated.
@@ -734,15 +848,10 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Gets the default workflow permissions granted to the `GITHUB_TOKEN` when running workflows in an enterprise,
-         * as well as whether GitHub Actions can submit approving pull request reviews. For more information, see
-         * "[Enforcing a policy for workflow permissions in your enterprise](https://docs.github.com/enterprise-cloud@latest/admin/policies/enforcing-policies-for-your-enterprise/enforcing-policies-for-github-actions-in-your-enterprise#enforcing-a-policy-for-workflow-permissions-in-your-enterprise)."
-         *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
-         * GitHub Apps must have the `enterprise_administration:write` permission to use this endpoint.
+         * Gets a specific variable in an environment. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `environments:read` repository permission to use this endpoint.
          */
-        getGithubActionsDefaultWorkflowPermissionsEnterprise: {
-            (params?: RestEndpointMethodTypes["actions"]["getGithubActionsDefaultWorkflowPermissionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["getGithubActionsDefaultWorkflowPermissionsEnterprise"]["response"]>;
+        getEnvironmentVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["getEnvironmentVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["getEnvironmentVariable"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
@@ -830,6 +939,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets a specific variable in an organization. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `organization_actions_variables:read` organization permission to use this endpoint.
+         */
+        getOrgVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["getOrgVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["getOrgVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Get all deployment environments for a workflow run that are waiting for protection rules to pass.
          *
@@ -865,6 +984,30 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets a specific required workflow present in a repository. Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. GitHub Apps must have the `actions:read` permission to use this endpoint. For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        getRepoRequiredWorkflow: {
+            (params?: RestEndpointMethodTypes["actions"]["getRepoRequiredWorkflow"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["getRepoRequiredWorkflow"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Gets the number of billable minutes used by a specific required workflow during the current billing cycle.
+         *
+         * Billable minutes only apply to required workflows running in private repositories that use GitHub-hosted runners. Usage is listed for each GitHub-hosted runner operating system in milliseconds. Any job re-runs are also included in the usage. The usage does not include the multiplier for macOS and Windows runners and is not rounded up to the nearest whole minute. For more information, see "[Managing billing for GitHub Actions](https://docs.github.com/github/setting-up-and-managing-billing-and-payments-on-github/managing-billing-for-github-actions)."
+         *
+         * Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. GitHub Apps must have the `actions:read` permission to use this endpoint.
+         */
+        getRepoRequiredWorkflowUsage: {
+            (params?: RestEndpointMethodTypes["actions"]["getRepoRequiredWorkflowUsage"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["getRepoRequiredWorkflowUsage"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Gets a single repository secret without revealing its encrypted value. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `secrets` repository permission to use this endpoint.
          */
@@ -875,6 +1018,30 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets a specific variable in a repository. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `actions_variables:read` repository permission to use this endpoint.
+         */
+        getRepoVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["getRepoVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["getRepoVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Get a required workflow configured in an organization.
+         *
+         * You must authenticate using an access token with the `read:org` scope to use this endpoint.
+         *
+         * For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        getRequiredWorkflow: {
+            (params?: RestEndpointMethodTypes["actions"]["getRequiredWorkflow"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["getRequiredWorkflow"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Anyone with read access to the repository can use this endpoint. If the repository is private, you must use an access token with the `repo` scope. GitHub Apps must have the `actions:read` permission to use this endpoint.
          */
@@ -922,7 +1089,8 @@ export declare type RestEndpointMethods = {
         };
         /**
          * Gets the level of access that workflows outside of the repository have to actions and reusable workflows in the repository.
-         * This endpoint only applies to internal repositories. For more information, see "[Managing GitHub Actions settings for a repository](https://docs.github.com/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-github-actions-settings-for-a-repository#allowing-access-to-components-in-an-internal-repository)."
+         * This endpoint only applies to private repositories.
+         * For more information, see "[Allowing access to components in a private repository](https://docs.github.com/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-github-actions-settings-for-a-repository#allowing-access-to-components-in-a-private-repository)."
          *
          * You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the
          * repository `administration` permission to use this endpoint.
@@ -1001,6 +1169,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Lists all environment variables. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `environments:read` repository permission to use this endpoint.
+         */
+        listEnvironmentVariables: {
+            (params?: RestEndpointMethodTypes["actions"]["listEnvironmentVariables"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listEnvironmentVariables"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Lists jobs for a workflow run. Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. GitHub Apps must have the `actions:read` permission to use this endpoint. You can use parameters to narrow the list of results. For more information about using parameters, see [Parameters](https://docs.github.com/rest/overview/resources-in-the-rest-api#parameters).
          */
@@ -1056,6 +1234,46 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Lists all organization variables. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `organization_actions_variables:read` organization permission to use this endpoint.
+         */
+        listOrgVariables: {
+            (params?: RestEndpointMethodTypes["actions"]["listOrgVariables"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listOrgVariables"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists all organization secrets shared with a repository without revealing their encrypted values. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `secrets` repository permission to use this endpoint.
+         */
+        listRepoOrganizationSecrets: {
+            (params?: RestEndpointMethodTypes["actions"]["listRepoOrganizationSecrets"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listRepoOrganizationSecrets"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists all organiation variables shared with a repository. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `actions_variables:read` repository permission to use this endpoint.
+         */
+        listRepoOrganizationVariables: {
+            (params?: RestEndpointMethodTypes["actions"]["listRepoOrganizationVariables"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listRepoOrganizationVariables"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists the required workflows in a repository. Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. GitHub Apps must have the `actions:read` permission to use this endpoint. For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        listRepoRequiredWorkflows: {
+            (params?: RestEndpointMethodTypes["actions"]["listRepoRequiredWorkflows"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listRepoRequiredWorkflows"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Lists all secrets available in a repository without revealing their encrypted values. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `secrets` repository permission to use this endpoint.
          */
@@ -1066,6 +1284,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Lists all repository variables. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `actions_variables:read` repository permission to use this endpoint.
+         */
+        listRepoVariables: {
+            (params?: RestEndpointMethodTypes["actions"]["listRepoVariables"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listRepoVariables"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Lists the workflows in a repository. Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. GitHub Apps must have the `actions:read` permission to use this endpoint.
          */
@@ -1076,6 +1304,32 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * List all workflow runs for a required workflow. You can use parameters to narrow the list of results. For more information about using parameters, see [Parameters](https://docs.github.com/rest/overview/resources-in-the-rest-api#parameters).
+         *
+         * Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        listRequiredWorkflowRuns: {
+            (params?: RestEndpointMethodTypes["actions"]["listRequiredWorkflowRuns"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listRequiredWorkflowRuns"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * List all required workflows in an organization.
+         *
+         * You must authenticate using an access token with the `read:org` scope to use this endpoint.
+         *
+         * For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        listRequiredWorkflows: {
+            (params?: RestEndpointMethodTypes["actions"]["listRequiredWorkflows"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listRequiredWorkflows"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Lists binaries for the runner application that you can download and run.
          *
@@ -1110,6 +1364,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Lists all repositories that can access an organization variable that is available to selected repositories. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `organization_actions_variables:read` organization permission to use this endpoint.
+         */
+        listSelectedReposForOrgVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["listSelectedReposForOrgVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listSelectedReposForOrgVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Lists the selected repositories that are enabled for GitHub Actions in an organization. To use this endpoint, the organization permission policy for `enabled_repositories` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for an organization](#set-github-actions-permissions-for-an-organization)."
          *
@@ -1122,6 +1386,20 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Lists the selected repositories that are configured for a required workflow in an organization. To use this endpoint, the required workflow must be configured to run on selected repositories.
+         *
+         * You must authenticate using an access token with the `read:org` scope to use this endpoint. GitHub Apps must have the `administration` organization permission to use this endpoint.
+         *
+         * For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        listSelectedRepositoriesRequiredWorkflow: {
+            (params?: RestEndpointMethodTypes["actions"]["listSelectedRepositoriesRequiredWorkflow"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["listSelectedRepositoriesRequiredWorkflow"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Lists all self-hosted runners configured in an organization.
          *
@@ -1278,6 +1556,45 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Removes a repository from an organization variable that is available to selected repositories. Organization variables that are available to selected repositories have their `visibility` field set to `selected`. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `organization_actions_variables:write` organization permission to use this endpoint.
+         */
+        removeSelectedRepoFromOrgVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["removeSelectedRepoFromOrgVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["removeSelectedRepoFromOrgVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Removes a repository from a required workflow. To use this endpoint, the required workflow must be configured to run on selected repositories.
+         *
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         *
+         * For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        removeSelectedRepoFromRequiredWorkflow: {
+            (params?: RestEndpointMethodTypes["actions"]["removeSelectedRepoFromRequiredWorkflow"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["removeSelectedRepoFromRequiredWorkflow"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Approve or reject custom deployment protection rules provided by a GitHub App for a workflow run. For more information, see "[Using environments for deployment](https://docs.github.com/actions/deployment/targeting-different-environments/using-environments-for-deployment)."
+         *
+         * **Note:** GitHub Apps can only review their own custom deployment protection rules.
+         * To approve or reject pending deployments that are waiting for review from a specific person or team, see [`POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments`](/rest/actions/workflow-runs#review-pending-deployments-for-a-workflow-run).
+         *
+         * GitHub Apps must have read and write permission for **Deployments** to use this endpoint.
+         */
+        reviewCustomGatesForRun: {
+            (params?: RestEndpointMethodTypes["actions"]["reviewCustomGatesForRun"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["reviewCustomGatesForRun"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Approve or reject pending deployments that are waiting on approval by a required reviewer.
          *
@@ -1293,10 +1610,6 @@ export declare type RestEndpointMethods = {
         /**
          * Sets the actions and reusable workflows that are allowed in an organization. To use this endpoint, the organization permission policy for `allowed_actions` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for an organization](#set-github-actions-permissions-for-an-organization)."
          *
-         * If the organization belongs to an enterprise that has `selected` actions and reusable workflows set at the enterprise level, then you cannot override any of the enterprise's allowed actions and reusable workflows settings.
-         *
-         * To use the `patterns_allowed` setting for private repositories, the organization must belong to an enterprise. If the organization does not belong to an enterprise, then the `patterns_allowed` setting only applies to public repositories in the organization.
-         *
          * You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `administration` organization permission to use this API.
          */
         setAllowedActionsOrganization: {
@@ -1309,10 +1622,6 @@ export declare type RestEndpointMethods = {
         /**
          * Sets the actions and reusable workflows that are allowed in a repository. To use this endpoint, the repository permission policy for `allowed_actions` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for a repository](#set-github-actions-permissions-for-a-repository)."
          *
-         * If the repository belongs to an organization or enterprise that has `selected` actions and reusable workflows set at the organization or enterprise levels, then you cannot override any of the allowed actions and reusable workflows settings.
-         *
-         * To use the `patterns_allowed` setting for private repositories, the repository must belong to an enterprise. If the repository does not belong to an enterprise, then the `patterns_allowed` setting only applies to public repositories.
-         *
          * You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `administration` repository permission to use this API.
          */
         setAllowedActionsRepository: {
@@ -1349,21 +1658,6 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
-        /**
-         * Sets the default workflow permissions granted to the `GITHUB_TOKEN` when running workflows in an enterprise, and sets
-         * whether GitHub Actions can submit approving pull request reviews. For more information, see
-         * "[Enforcing a policy for workflow permissions in your enterprise](https://docs.github.com/enterprise-cloud@latest/admin/policies/enforcing-policies-for-your-enterprise/enforcing-policies-for-github-actions-in-your-enterprise#enforcing-a-policy-for-workflow-permissions-in-your-enterprise)."
-         *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
-         * GitHub Apps must have the `enterprise_administration:write` permission to use this endpoint.
-         */
-        setGithubActionsDefaultWorkflowPermissionsEnterprise: {
-            (params?: RestEndpointMethodTypes["actions"]["setGithubActionsDefaultWorkflowPermissionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["setGithubActionsDefaultWorkflowPermissionsEnterprise"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
         /**
          * Sets the default workflow permissions granted to the `GITHUB_TOKEN` when running workflows in an organization, and sets if GitHub Actions
          * can submit approving pull request reviews. For more information, see
@@ -1395,8 +1689,6 @@ export declare type RestEndpointMethods = {
         /**
          * Sets the GitHub Actions permissions policy for repositories and allowed actions and reusable workflows in an organization.
          *
-         * If the organization belongs to an enterprise that has set restrictive permissions at the enterprise level, such as `allowed_actions` to `selected` actions and reusable workflows, then you cannot override them for the organization.
-         *
          * You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `administration` organization permission to use this API.
          */
         setGithubActionsPermissionsOrganization: {
@@ -1409,8 +1701,6 @@ export declare type RestEndpointMethods = {
         /**
          * Sets the GitHub Actions permissions policy for enabling GitHub Actions and allowed actions and reusable workflows in the repository.
          *
-         * If the repository belongs to an organization or enterprise that has set restrictive permissions at the organization or enterprise levels, such as `allowed_actions` to `selected` actions and reusable workflows, then you cannot override them for the repository.
-         *
          * You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `administration` repository permission to use this API.
          */
         setGithubActionsPermissionsRepository: {
@@ -1430,6 +1720,30 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Replaces all repositories for an organization variable that is available to selected repositories. Organization variables that are available to selected repositories have their `visibility` field set to `selected`. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `organization_actions_variables:write` organization permission to use this endpoint.
+         */
+        setSelectedReposForOrgVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["setSelectedReposForOrgVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["setSelectedReposForOrgVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Sets the repositories for a required workflow that is required for selected repositories.
+         *
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         *
+         * For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        setSelectedReposToRequiredWorkflow: {
+            (params?: RestEndpointMethodTypes["actions"]["setSelectedReposToRequiredWorkflow"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["setSelectedReposToRequiredWorkflow"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Replaces the list of selected repositories that are enabled for GitHub Actions in an organization. To use this endpoint, the organization permission policy for `enabled_repositories` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for an organization](#set-github-actions-permissions-for-an-organization)."
          *
@@ -1444,7 +1758,8 @@ export declare type RestEndpointMethods = {
         };
         /**
          * Sets the level of access that workflows outside of the repository have to actions and reusable workflows in the repository.
-         * This endpoint only applies to internal repositories. For more information, see "[Managing GitHub Actions settings for a repository](https://docs.github.com/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-github-actions-settings-for-a-repository#allowing-access-to-components-in-an-internal-repository)."
+         * This endpoint only applies to private repositories.
+         * For more information, see "[Allowing access to components in a private repository](https://docs.github.com/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-github-actions-settings-for-a-repository#allowing-access-to-components-in-a-private-repository)".
          *
          * You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the
          * repository `administration` permission to use this endpoint.
@@ -1456,6 +1771,56 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Updates an environment variable that you can reference in a GitHub Actions workflow.
+         * You must authenticate using an access token with the `repo` scope to use this endpoint.
+         * GitHub Apps must have the `environment:write` repository permission to use this endpoint.
+         */
+        updateEnvironmentVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["updateEnvironmentVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["updateEnvironmentVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Updates an organization variable that you can reference in a GitHub Actions workflow.
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         * GitHub Apps must have the `organization_actions_variables:write` organization permission to use this endpoint.
+         */
+        updateOrgVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["updateOrgVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["updateOrgVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Updates a repository variable that you can reference in a GitHub Actions workflow.
+         * You must authenticate using an access token with the `repo` scope to use this endpoint.
+         * GitHub Apps must have the `actions_variables:write` repository permission to use this endpoint.
+         */
+        updateRepoVariable: {
+            (params?: RestEndpointMethodTypes["actions"]["updateRepoVariable"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["updateRepoVariable"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Update a required workflow in an organization.
+         *
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         *
+         * For more information, see "[Required Workflows](https://docs.github.com/actions/using-workflows/required-workflows)."
+         */
+        updateRequiredWorkflow: {
+            (params?: RestEndpointMethodTypes["actions"]["updateRequiredWorkflow"]["parameters"]): Promise<RestEndpointMethodTypes["actions"]["updateRequiredWorkflow"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
     };
     activity: {
         checkRepoIsStarredByAuthenticatedUser: {
@@ -1512,6 +1877,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets information about a notification thread.
+         */
         getThread: {
             (params?: RestEndpointMethodTypes["activity"]["getThread"]["parameters"]): Promise<RestEndpointMethodTypes["activity"]["getThread"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -1609,6 +1977,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * **Note**: This API is not built to serve real-time use cases. Depending on the time of day, event latency can be anywhere from 30s to 6h.
+         */
         listRepoEvents: {
             (params?: RestEndpointMethodTypes["activity"]["listRepoEvents"]["parameters"]): Promise<RestEndpointMethodTypes["activity"]["listRepoEvents"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -1617,7 +1988,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * List all notifications for the current user.
+         * Lists all notifications for the current user in the specified repository.
          */
         listRepoNotificationsForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["activity"]["listRepoNotificationsForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["activity"]["listRepoNotificationsForAuthenticatedUser"]["response"]>;
@@ -1693,7 +2064,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Marks all notifications as "read" removes it from the [default view on GitHub](https://github.com/notifications). If the number of notifications is too large to complete in one request, you will receive a `202 Accepted` status and GitHub will run an asynchronous process to mark notifications as "read." To check whether any "unread" notifications remain, you can use the [List notifications for the authenticated user](https://docs.github.com/rest/reference/activity#list-notifications-for-the-authenticated-user) endpoint and pass the query parameter `all=false`.
+         * Marks all notifications as "read" for the current user. If the number of notifications is too large to complete in one request, you will receive a `202 Accepted` status and GitHub will run an asynchronous process to mark notifications as "read." To check whether any "unread" notifications remain, you can use the [List notifications for the authenticated user](https://docs.github.com/rest/reference/activity#list-notifications-for-the-authenticated-user) endpoint and pass the query parameter `all=false`.
          */
         markNotificationsAsRead: {
             (params?: RestEndpointMethodTypes["activity"]["markNotificationsAsRead"]["parameters"]): Promise<RestEndpointMethodTypes["activity"]["markNotificationsAsRead"]["response"]>;
@@ -1703,7 +2074,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Marks all notifications in a repository as "read" removes them from the [default view on GitHub](https://github.com/notifications). If the number of notifications is too large to complete in one request, you will receive a `202 Accepted` status and GitHub will run an asynchronous process to mark notifications as "read." To check whether any "unread" notifications remain, you can use the [List repository notifications for the authenticated user](https://docs.github.com/rest/reference/activity#list-repository-notifications-for-the-authenticated-user) endpoint and pass the query parameter `all=false`.
+         * Marks all notifications in a repository as "read" for the current user. If the number of notifications is too large to complete in one request, you will receive a `202 Accepted` status and GitHub will run an asynchronous process to mark notifications as "read." To check whether any "unread" notifications remain, you can use the [List repository notifications for the authenticated user](https://docs.github.com/rest/reference/activity#list-repository-notifications-for-the-authenticated-user) endpoint and pass the query parameter `all=false`.
          */
         markRepoNotificationsAsRead: {
             (params?: RestEndpointMethodTypes["activity"]["markRepoNotificationsAsRead"]["parameters"]): Promise<RestEndpointMethodTypes["activity"]["markRepoNotificationsAsRead"]["response"]>;
@@ -1712,6 +2083,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Marks a thread as "read." Marking a thread as "read" is equivalent to clicking a notification in your notification inbox on GitHub: https://github.com/notifications.
+         */
         markThreadAsRead: {
             (params?: RestEndpointMethodTypes["activity"]["markThreadAsRead"]["parameters"]): Promise<RestEndpointMethodTypes["activity"]["markThreadAsRead"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -1788,7 +2162,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * OAuth applications can use a special API method for checking OAuth token validity without exceeding the normal rate limits for failed login attempts. Authentication works differently with this particular endpoint. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) to use this endpoint, where the username is the OAuth application `client_id` and the password is its `client_secret`. Invalid tokens will return `404 NOT FOUND`.
+         * OAuth applications and GitHub applications with OAuth authorizations can use this API method for checking OAuth token validity without exceeding the normal rate limits for failed login attempts. Authentication works differently with this particular endpoint. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) to use this endpoint, where the username is the application `client_id` and the password is its `client_secret`. Invalid tokens will return `404 NOT FOUND`.
          */
         checkToken: {
             (params?: RestEndpointMethodTypes["apps"]["checkToken"]["parameters"]): Promise<RestEndpointMethodTypes["apps"]["checkToken"]["response"]>;
@@ -1820,8 +2194,8 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * OAuth application owners can revoke a grant for their OAuth application and a specific user. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) when accessing this endpoint, using the OAuth application's `client_id` and `client_secret` as the username and password. You must also provide a valid OAuth `access_token` as an input parameter and the grant for the token's owner will be deleted.
-         * Deleting an OAuth application's grant will also delete all OAuth tokens associated with the application for the user. Once deleted, the application will have no access to the user's account and will no longer be listed on [the application authorizations settings screen within GitHub](https://github.com/settings/applications#authorized).
+         * OAuth and GitHub application owners can revoke a grant for their application and a specific user. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) when accessing this endpoint, using the OAuth application's `client_id` and `client_secret` as the username and password. You must also provide a valid OAuth `access_token` as an input parameter and the grant for the token's owner will be deleted.
+         * Deleting an application's grant will also delete all OAuth tokens associated with the application for the user. Once deleted, the application will have no access to the user's account and will no longer be listed on [the application authorizations settings screen within GitHub](https://github.com/settings/applications#authorized).
          */
         deleteAuthorization: {
             (params?: RestEndpointMethodTypes["apps"]["deleteAuthorization"]["parameters"]): Promise<RestEndpointMethodTypes["apps"]["deleteAuthorization"]["response"]>;
@@ -1843,7 +2217,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * OAuth application owners can revoke a single token for an OAuth application. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) when accessing this endpoint, using the OAuth application's `client_id` and `client_secret` as the username and password.
+         * OAuth  or GitHub application owners can revoke a single token for an OAuth application or a GitHub application with an OAuth authorization. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) when accessing this endpoint, using the application's `client_id` and `client_secret` as the username and password.
          */
         deleteToken: {
             (params?: RestEndpointMethodTypes["apps"]["deleteToken"]["parameters"]): Promise<RestEndpointMethodTypes["apps"]["deleteToken"]["response"]>;
@@ -2012,6 +2386,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Lists all the pending installation requests for the authenticated GitHub App.
+         */
+        listInstallationRequestsForAuthenticatedApp: {
+            (params?: RestEndpointMethodTypes["apps"]["listInstallationRequestsForAuthenticatedApp"]["parameters"]): Promise<RestEndpointMethodTypes["apps"]["listInstallationRequestsForAuthenticatedApp"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * You must use a [JWT](https://docs.github.com/apps/building-github-apps/authenticating-with-github-apps/#authenticating-as-a-github-app) to access this endpoint.
          *
@@ -2146,7 +2530,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * OAuth applications can use this API method to reset a valid OAuth token without end-user involvement. Applications must save the "token" property in the response because changes take effect immediately. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) when accessing this endpoint, using the OAuth application's `client_id` and `client_secret` as the username and password. Invalid tokens will return `404 NOT FOUND`.
+         * OAuth applications and GitHub applications with OAuth authorizations can use this API method to reset a valid OAuth token without end-user involvement. Applications must save the "token" property in the response because changes take effect immediately. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) when accessing this endpoint, using the application's `client_id` and `client_secret` as the username and password. Invalid tokens will return `404 NOT FOUND`.
          */
         resetToken: {
             (params?: RestEndpointMethodTypes["apps"]["resetToken"]["parameters"]): Promise<RestEndpointMethodTypes["apps"]["resetToken"]["response"]>;
@@ -2170,7 +2554,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Use a non-scoped user-to-server OAuth access token to create a repository scoped and/or permission scoped user-to-server OAuth access token. You can specify which repositories the token can access and which permissions are granted to the token. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) when accessing this endpoint, using the OAuth application's `client_id` and `client_secret` as the username and password. Invalid tokens will return `404 NOT FOUND`.
+         * Use a non-scoped user-to-server access token to create a repository scoped and/or permission scoped user-to-server access token. You can specify which repositories the token can access and which permissions are granted to the token. You must use [Basic Authentication](https://docs.github.com/rest/overview/other-authentication-methods#basic-authentication) when accessing this endpoint, using the `client_id` and `client_secret` of the GitHub App as the username and password. Invalid tokens will return `404 NOT FOUND`.
          */
         scopeToken: {
             (params?: RestEndpointMethodTypes["apps"]["scopeToken"]["parameters"]): Promise<RestEndpointMethodTypes["apps"]["scopeToken"]["response"]>;
@@ -2207,69 +2591,39 @@ export declare type RestEndpointMethods = {
          * Updates the webhook configuration for a GitHub App. For more information about configuring a webhook for your app, see "[Creating a GitHub App](/developers/apps/creating-a-github-app)."
          *
          * You must use a [JWT](https://docs.github.com/apps/building-github-apps/authenticating-with-github-apps/#authenticating-as-a-github-app) to access this endpoint.
-         */
-        updateWebhookConfigForApp: {
-            (params?: RestEndpointMethodTypes["apps"]["updateWebhookConfigForApp"]["parameters"]): Promise<RestEndpointMethodTypes["apps"]["updateWebhookConfigForApp"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-    };
-    billing: {
-        /**
-         * Gets the summary of the free and paid GitHub Actions minutes used.
-         *
-         * Paid minutes only apply to workflows in private repositories that use GitHub-hosted runners. Minutes used is listed for each GitHub-hosted runner operating system. Any job re-runs are also included in the usage. The usage returned includes any minute multipliers for macOS and Windows runners, and is rounded up to the nearest whole minute. For more information, see "[Managing billing for GitHub Actions](https://docs.github.com/github/setting-up-and-managing-billing-and-payments-on-github/managing-billing-for-github-actions)".
-         *
-         * Access tokens must have the `repo` or `admin:org` scope.
-         */
-        getGithubActionsBillingOrg: {
-            (params?: RestEndpointMethodTypes["billing"]["getGithubActionsBillingOrg"]["parameters"]): Promise<RestEndpointMethodTypes["billing"]["getGithubActionsBillingOrg"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Gets the summary of the free and paid GitHub Actions minutes used.
-         *
-         * Paid minutes only apply to workflows in private repositories that use GitHub-hosted runners. Minutes used is listed for each GitHub-hosted runner operating system. Any job re-runs are also included in the usage. The usage returned includes any minute multipliers for macOS and Windows runners, and is rounded up to the nearest whole minute. For more information, see "[Managing billing for GitHub Actions](https://docs.github.com/github/setting-up-and-managing-billing-and-payments-on-github/managing-billing-for-github-actions)".
-         *
-         * Access tokens must have the `user` scope.
-         */
-        getGithubActionsBillingUser: {
-            (params?: RestEndpointMethodTypes["billing"]["getGithubActionsBillingUser"]["parameters"]): Promise<RestEndpointMethodTypes["billing"]["getGithubActionsBillingUser"]["response"]>;
+         */
+        updateWebhookConfigForApp: {
+            (params?: RestEndpointMethodTypes["apps"]["updateWebhookConfigForApp"]["parameters"]): Promise<RestEndpointMethodTypes["apps"]["updateWebhookConfigForApp"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
+    };
+    billing: {
         /**
-         * Gets the GitHub Advanced Security active committers for an enterprise per repository.
+         * Gets the summary of the free and paid GitHub Actions minutes used.
          *
-         * Each distinct user login across all repositories is counted as a single Advanced Security seat, so the `total_advanced_security_committers` is not the sum of active_users for each repository.
+         * Paid minutes only apply to workflows in private repositories that use GitHub-hosted runners. Minutes used is listed for each GitHub-hosted runner operating system. Any job re-runs are also included in the usage. The usage returned includes any minute multipliers for macOS and Windows runners, and is rounded up to the nearest whole minute. For more information, see "[Managing billing for GitHub Actions](https://docs.github.com/github/setting-up-and-managing-billing-and-payments-on-github/managing-billing-for-github-actions)".
          *
-         * The total number of repositories with committer information is tracked by the `total_count` field.
+         * Access tokens must have the `repo` or `admin:org` scope.
          */
-        getGithubAdvancedSecurityBillingGhe: {
-            (params?: RestEndpointMethodTypes["billing"]["getGithubAdvancedSecurityBillingGhe"]["parameters"]): Promise<RestEndpointMethodTypes["billing"]["getGithubAdvancedSecurityBillingGhe"]["response"]>;
+        getGithubActionsBillingOrg: {
+            (params?: RestEndpointMethodTypes["billing"]["getGithubActionsBillingOrg"]["parameters"]): Promise<RestEndpointMethodTypes["billing"]["getGithubActionsBillingOrg"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Gets the GitHub Advanced Security active committers for an organization per repository.
-         *
-         * Each distinct user login across all repositories is counted as a single Advanced Security seat, so the `total_advanced_security_committers` is not the sum of advanced_security_committers for each repository.
+         * Gets the summary of the free and paid GitHub Actions minutes used.
          *
-         * If this organization defers to an enterprise for billing, the `total_advanced_security_committers` returned from the organization API may include some users that are in more than one organization, so they will only consume a single Advanced Security seat at the enterprise level.
+         * Paid minutes only apply to workflows in private repositories that use GitHub-hosted runners. Minutes used is listed for each GitHub-hosted runner operating system. Any job re-runs are also included in the usage. The usage returned includes any minute multipliers for macOS and Windows runners, and is rounded up to the nearest whole minute. For more information, see "[Managing billing for GitHub Actions](https://docs.github.com/github/setting-up-and-managing-billing-and-payments-on-github/managing-billing-for-github-actions)".
          *
-         * The total number of repositories with committer information is tracked by the `total_count` field.
+         * Access tokens must have the `user` scope.
          */
-        getGithubAdvancedSecurityBillingOrg: {
-            (params?: RestEndpointMethodTypes["billing"]["getGithubAdvancedSecurityBillingOrg"]["parameters"]): Promise<RestEndpointMethodTypes["billing"]["getGithubAdvancedSecurityBillingOrg"]["response"]>;
+        getGithubActionsBillingUser: {
+            (params?: RestEndpointMethodTypes["billing"]["getGithubActionsBillingUser"]["parameters"]): Promise<RestEndpointMethodTypes["billing"]["getGithubActionsBillingUser"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
@@ -2553,9 +2907,6 @@ export declare type RestEndpointMethods = {
         };
         /**
          * Gets a single code scanning alert. You must use an access token with the `security_events` scope to use this endpoint with private repos, the `public_repo` scope also grants permission to read security events on public repos only. GitHub Apps must have the `security_events` read permission to use this endpoint.
-         *
-         * **Deprecation notice**:
-         * The instances field is deprecated and will, in future, not be included in the response for this endpoint. The example response reflects this change. The same information can now be retrieved via a GET request to the URL specified by `instances_url`.
          */
         getAlert: {
             (params?: RestEndpointMethodTypes["codeScanning"]["getAlert"]["parameters"]): Promise<RestEndpointMethodTypes["codeScanning"]["getAlert"]["response"]>;
@@ -2612,6 +2963,18 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets a code scanning default setup configuration.
+         * You must use an access token with the `repo` scope to use this endpoint with private repos or the `public_repo`
+         * scope for public repos. GitHub Apps must have the `repo` write permission to use this endpoint.
+         */
+        getDefaultSetup: {
+            (params?: RestEndpointMethodTypes["codeScanning"]["getDefaultSetup"]["parameters"]): Promise<RestEndpointMethodTypes["codeScanning"]["getDefaultSetup"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Gets information about a SARIF upload, including the status and the URL of the analysis that was uploaded so that you can retrieve details of the analysis. For more information, see "[Get a code scanning analysis for a repository](/rest/reference/code-scanning#get-a-code-scanning-analysis-for-a-repository)." You must use an access token with the `security_events` scope to use this endpoint with private repos, the `public_repo` scope also grants permission to read security events on public repos only. GitHub Apps must have the `security_events` read permission to use this endpoint.
          */
@@ -2635,19 +2998,6 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
-        /**
-         * Lists code scanning alerts for the default branch for all eligible repositories in an enterprise. Eligible repositories are repositories that are owned by organizations that you own or for which you are a security manager. For more information, see "[Managing security managers in your organization](https://docs.github.com/organizations/managing-peoples-access-to-your-organization-with-roles/managing-security-managers-in-your-organization)."
-         *
-         * To use this endpoint, you must be a member of the enterprise,
-         * and you must use an access token with the `repo` scope or `security_events` scope.
-         */
-        listAlertsForEnterprise: {
-            (params?: RestEndpointMethodTypes["codeScanning"]["listAlertsForEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["codeScanning"]["listAlertsForEnterprise"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
         /**
          * Lists code scanning alerts for the default branch for all eligible repositories in an organization. Eligible repositories are repositories that are owned by organizations that you own or for which you are a security manager. For more information, see "[Managing security managers in your organization](https://docs.github.com/organizations/managing-peoples-access-to-your-organization-with-roles/managing-security-managers-in-your-organization)."
          *
@@ -2747,6 +3097,18 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Updates a code scanning default setup configuration.
+         * You must use an access token with the `repo` scope to use this endpoint with private repos or the `public_repo`
+         * scope for public repos. GitHub Apps must have the `repo` write permission to use this endpoint.
+         */
+        updateDefaultSetup: {
+            (params?: RestEndpointMethodTypes["codeScanning"]["updateDefaultSetup"]["parameters"]): Promise<RestEndpointMethodTypes["codeScanning"]["updateDefaultSetup"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Uploads SARIF data containing the results of a code scanning analysis to make the results available in a repository. You must use an access token with the `security_events` scope to use this endpoint for private repositories. You can also use tokens with the `public_repo` scope for public repositories only. GitHub Apps must have the `security_events` write permission to use this endpoint.
          *
@@ -2759,11 +3121,24 @@ export declare type RestEndpointMethods = {
          * ```
          * gzip -c analysis-data.sarif | base64 -w0
          * ```
+         * <br>
+         * SARIF upload supports a maximum number of entries per the following data objects, and an analysis will be rejected if any of these objects is above its maximum value. For some objects, there are additional values over which the entries will be ignored while keeping the most important entries whenever applicable.
+         * To get the most out of your analysis when it includes data above the supported limits, try to optimize the analysis configuration. For example, for the CodeQL tool, identify and remove the most noisy queries.
+         *
          *
-         * SARIF upload supports a maximum of 5000 results per analysis run. Any results over this limit are ignored and any SARIF uploads with more than 25,000 results are rejected. Typically, but not necessarily, a SARIF file contains a single run of a single tool. If a code scanning tool generates too many results, you should update the analysis configuration to run only the most important rules or queries.
+         * | **SARIF data**                   | **Maximum values** | **Additional limits**                                                            |
+         * |----------------------------------|:------------------:|----------------------------------------------------------------------------------|
+         * | Runs per file                    |         20         |                                                                                  |
+         * | Results per run                  |       25,000       | Only the top 5,000 results will be included, prioritized by severity.            |
+         * | Rules per run                    |       25,000       |                                                                                  |
+         * | Tool extensions per run          |        100         |                                                                                  |
+         * | Thread Flow Locations per result |       10,000       | Only the top 1,000 Thread Flow Locations will be included, using prioritization. |
+         * | Location per result	             |       1,000        | Only 100 locations will be included.                                             |
+         * | Tags per rule	                   |         20         | Only 10 tags will be included.                                                   |
          *
-         * The `202 Accepted`, response includes an `id` value.
-         * You can use this ID to check the status of the upload by using this for the `/sarifs/{sarif_id}` endpoint.
+         *
+         * The `202 Accepted` response includes an `id` value.
+         * You can use this ID to check the status of the upload by using it in the `/sarifs/{sarif_id}` endpoint.
          * For more information, see "[Get information about a SARIF upload](/rest/reference/code-scanning#get-information-about-a-sarif-upload)."
          */
         uploadSarif: {
@@ -2853,26 +3228,23 @@ export declare type RestEndpointMethods = {
          * Encrypt your secret using the [libsodium-wrappers](https://www.npmjs.com/package/libsodium-wrappers) library.
          *
          * ```
-         * // Written with ❤️ by PSJ and free to use under The Unlicense.
-         * const sodium=require('libsodium-wrappers')
-         * const secret = 'plain-text-secret' // replace with secret before running the script.
-         * const key = 'base64-encoded-public-key' // replace with the Base64 encoded public key.
+         * const sodium = require('libsodium-wrappers')
+         * const secret = 'plain-text-secret' // replace with the secret you want to encrypt
+         * const key = 'base64-encoded-public-key' // replace with the Base64 encoded public key
          *
          * //Check if libsodium is ready and then proceed.
+         * sodium.ready.then(() => {
+         *   // Convert Secret & Base64 key to Uint8Array.
+         *   let binkey = sodium.from_base64(key, sodium.base64_variants.ORIGINAL)
+         *   let binsec = sodium.from_string(secret)
          *
-         * sodium.ready.then( ()=>{
-         *
-         * // Convert Secret & Base64 key to Uint8Array.
-         * let binkey= sodium.from_base64(key, sodium.base64_variants.ORIGINAL) //Equivalent of Buffer.from(key, 'base64')
-         * let binsec= sodium.from_string(secret) // Equivalent of Buffer.from(secret)
+         *   //Encrypt the secret using LibSodium
+         *   let encBytes = sodium.crypto_box_seal(binsec, binkey)
          *
-         * //Encrypt the secret using LibSodium
-         * let encBytes= sodium.crypto_box_seal(binsec,binkey) // Similar to tweetsodium.seal(binsec,binkey)
+         *   // Convert encrypted Uint8Array to Base64
+         *   let output = sodium.to_base64(encBytes, sodium.base64_variants.ORIGINAL)
          *
-         * // Convert encrypted Uint8Array to Base64
-         * let output=sodium.to_base64(encBytes, sodium.base64_variants.ORIGINAL) //Equivalent of Buffer.from(encBytes).toString('base64')
-         *
-         * console.log(output)
+         *   console.log(output)
          * });
          * ```
          *
@@ -2933,33 +3305,34 @@ export declare type RestEndpointMethods = {
         /**
          * Creates or updates a repository secret with an encrypted value. Encrypt your secret using
          * [LibSodium](https://libsodium.gitbook.io/doc/bindings_for_other_languages). You must authenticate using an access
-         * token with the `repo` scope to use this endpoint. GitHub Apps must have the `codespaces_secrets` repository
-         * permission to use this endpoint.
+         * token with the `repo` scope to use this endpoint. GitHub Apps must have write access to the `codespaces_secrets`
+         * repository permission to use this endpoint.
          *
          * #### Example of encrypting a secret using Node.js
          *
-         * Encrypt your secret using the [tweetsodium](https://github.com/github/tweetsodium) library.
+         * Encrypt your secret using the [libsodium-wrappers](https://www.npmjs.com/package/libsodium-wrappers) library.
          *
          * ```
-         * const sodium = require('tweetsodium');
-         *
-         * const key = "base64-encoded-public-key";
-         * const value = "plain-text-secret";
+         * const sodium = require('libsodium-wrappers')
+         * const secret = 'plain-text-secret' // replace with the secret you want to encrypt
+         * const key = 'base64-encoded-public-key' // replace with the Base64 encoded public key
          *
-         * // Convert the message and key to Uint8Array's (Buffer implements that interface)
-         * const messageBytes = Buffer.from(value);
-         * const keyBytes = Buffer.from(key, 'base64');
+         * //Check if libsodium is ready and then proceed.
+         * sodium.ready.then(() => {
+         *   // Convert Secret & Base64 key to Uint8Array.
+         *   let binkey = sodium.from_base64(key, sodium.base64_variants.ORIGINAL)
+         *   let binsec = sodium.from_string(secret)
          *
-         * // Encrypt using LibSodium.
-         * const encryptedBytes = sodium.seal(messageBytes, keyBytes);
+         *   //Encrypt the secret using LibSodium
+         *   let encBytes = sodium.crypto_box_seal(binsec, binkey)
          *
-         * // Base64 the encrypted secret
-         * const encrypted = Buffer.from(encryptedBytes).toString('base64');
+         *   // Convert encrypted Uint8Array to Base64
+         *   let output = sodium.to_base64(encBytes, sodium.base64_variants.ORIGINAL)
          *
-         * console.log(encrypted);
+         *   console.log(output)
+         * });
          * ```
          *
-         *
          * #### Example of encrypting a secret using Python
          *
          * Encrypt your secret using [pynacl](https://pynacl.readthedocs.io/en/latest/public/#nacl-public-sealedbox) with Python 3.
@@ -3020,32 +3393,33 @@ export declare type RestEndpointMethods = {
          *
          * You must authenticate using an access token with the `codespace` or `codespace:secrets` scope to use this endpoint. User must also have Codespaces access to use this endpoint.
          *
-         * GitHub Apps must have read access to the `codespaces_user_secrets` user permission and `codespaces_secrets` repository permission on all referenced repositories to use this endpoint.
+         * GitHub Apps must have write access to the `codespaces_user_secrets` user permission and `codespaces_secrets` repository permission on all referenced repositories to use this endpoint.
          *
          * #### Example encrypting a secret using Node.js
          *
-         * Encrypt your secret using the [tweetsodium](https://github.com/github/tweetsodium) library.
+         * Encrypt your secret using the [libsodium-wrappers](https://www.npmjs.com/package/libsodium-wrappers) library.
          *
          * ```
-         * const sodium = require('tweetsodium');
-         *
-         * const key = "base64-encoded-public-key";
-         * const value = "plain-text-secret";
+         * const sodium = require('libsodium-wrappers')
+         * const secret = 'plain-text-secret' // replace with the secret you want to encrypt
+         * const key = 'base64-encoded-public-key' // replace with the Base64 encoded public key
          *
-         * // Convert the message and key to Uint8Array's (Buffer implements that interface)
-         * const messageBytes = Buffer.from(value);
-         * const keyBytes = Buffer.from(key, 'base64');
+         * //Check if libsodium is ready and then proceed.
+         * sodium.ready.then(() => {
+         *   // Convert Secret & Base64 key to Uint8Array.
+         *   let binkey = sodium.from_base64(key, sodium.base64_variants.ORIGINAL)
+         *   let binsec = sodium.from_string(secret)
          *
-         * // Encrypt using LibSodium.
-         * const encryptedBytes = sodium.seal(messageBytes, keyBytes);
+         *   //Encrypt the secret using LibSodium
+         *   let encBytes = sodium.crypto_box_seal(binsec, binkey)
          *
-         * // Base64 the encrypted secret
-         * const encrypted = Buffer.from(encryptedBytes).toString('base64');
+         *   // Convert encrypted Uint8Array to Base64
+         *   let output = sodium.to_base64(encBytes, sodium.base64_variants.ORIGINAL)
          *
-         * console.log(encrypted);
+         *   console.log(output)
+         * });
          * ```
          *
-         *
          * #### Example encrypting a secret using Python
          *
          * Encrypt your secret using [pynacl](https://pynacl.readthedocs.io/en/latest/public/#nacl-public-sealedbox) with Python 3.
@@ -3128,6 +3502,17 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Codespaces for the specified users will no longer be billed to the organization.
+         * To use this endpoint, the billing settings for the organization must be set to `selected_members`. For information on how to change this setting please see [these docs].(https://docs.github.com/rest/codespaces/organizations#manage-access-control-for-organization-codespaces) You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         */
+        deleteCodespacesBillingUsers: {
+            (params?: RestEndpointMethodTypes["codespaces"]["deleteCodespacesBillingUsers"]["parameters"]): Promise<RestEndpointMethodTypes["codespaces"]["deleteCodespacesBillingUsers"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Deletes a user's codespace.
          *
@@ -3165,7 +3550,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Deletes a secret in a repository using the secret name. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `codespaces_secrets` repository permission to use this endpoint.
+         * Deletes a secret in a repository using the secret name. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have write access to the `codespaces_secrets` repository permission to use this endpoint.
          */
         deleteRepoSecret: {
             (params?: RestEndpointMethodTypes["codespaces"]["deleteRepoSecret"]["parameters"]): Promise<RestEndpointMethodTypes["codespaces"]["deleteRepoSecret"]["response"]>;
@@ -3191,6 +3576,8 @@ export declare type RestEndpointMethods = {
         /**
          * Triggers an export of the specified codespace and returns a URL and ID where the status of the export can be monitored.
          *
+         * If changes cannot be pushed to the codespace's repository, they will be pushed to a new or previously-existing fork instead.
+         *
          * You must authenticate using a personal access token with the `codespace` scope to use this endpoint.
          *
          * GitHub Apps must have write access to the `codespaces_lifecycle_admin` repository permission to use this endpoint.
@@ -3202,6 +3589,18 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Lists the codespaces that a member of an organization has for repositories in that organization.
+         *
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         */
+        getCodespacesForUserInOrg: {
+            (params?: RestEndpointMethodTypes["codespaces"]["getCodespacesForUserInOrg"]["parameters"]): Promise<RestEndpointMethodTypes["codespaces"]["getCodespacesForUserInOrg"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Gets information about an export of a codespace.
          *
@@ -3266,7 +3665,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Gets your public key, which you need to encrypt secrets. You need to encrypt a secret before you can create or update secrets. Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. GitHub Apps must have the `codespaces_secrets` repository permission to use this endpoint.
+         * Gets your public key, which you need to encrypt secrets. You need to encrypt a secret before you can create or update secrets. Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. GitHub Apps must have write access to the `codespaces_secrets` repository permission to use this endpoint.
          */
         getRepoPublicKey: {
             (params?: RestEndpointMethodTypes["codespaces"]["getRepoPublicKey"]["parameters"]): Promise<RestEndpointMethodTypes["codespaces"]["getRepoPublicKey"]["response"]>;
@@ -3276,7 +3675,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Gets a single repository secret without revealing its encrypted value. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `codespaces_secrets` repository permission to use this endpoint.
+         * Gets a single repository secret without revealing its encrypted value. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have write access to the `codespaces_secrets` repository permission to use this endpoint.
          */
         getRepoSecret: {
             (params?: RestEndpointMethodTypes["codespaces"]["getRepoSecret"]["parameters"]): Promise<RestEndpointMethodTypes["codespaces"]["getRepoSecret"]["response"]>;
@@ -3366,7 +3765,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Lists all secrets available in a repository without revealing their encrypted values. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `codespaces_secrets` repository permission to use this endpoint.
+         * Lists all secrets available in a repository without revealing their encrypted values. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have write access to the `codespaces_secrets` repository permission to use this endpoint.
          */
         listRepoSecrets: {
             (params?: RestEndpointMethodTypes["codespaces"]["listRepoSecrets"]["parameters"]): Promise<RestEndpointMethodTypes["codespaces"]["listRepoSecrets"]["response"]>;
@@ -3428,6 +3827,24 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Publishes an unpublished codespace, creating a new repository and assigning it to the codespace.
+         *
+         * The codespace's token is granted write permissions to the repository, allowing the user to push their changes.
+         *
+         * This will fail for a codespace that is already published, meaning it has an associated repository.
+         *
+         * You must authenticate using a personal access token with the `codespace` scope to use this endpoint.
+         *
+         * GitHub Apps must have write access to the `codespaces` repository permission to use this endpoint.
+         */
+        publishForAuthenticatedUser: {
+            (params?: RestEndpointMethodTypes["codespaces"]["publishForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["codespaces"]["publishForAuthenticatedUser"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Removes a repository from the selected repositories for a user's codespace secret.
          * You must authenticate using an access token with the `codespace` or `codespace:secrets` scope to use this endpoint. User must have Codespaces access to use this endpoint.
@@ -3464,6 +3881,28 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Sets which users can access codespaces in an organization. This is synonymous with granting or revoking codespaces billing permissions for users according to the visibility.
+         * You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         */
+        setCodespacesBilling: {
+            (params?: RestEndpointMethodTypes["codespaces"]["setCodespacesBilling"]["parameters"]): Promise<RestEndpointMethodTypes["codespaces"]["setCodespacesBilling"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Codespaces for the specified users will be billed to the organization.
+         * To use this endpoint, the billing settings for the organization must be set to `selected_members`. For information on how to change this setting please see [these docs].(https://docs.github.com/rest/codespaces/organizations#manage-access-control-for-organization-codespaces) You must authenticate using an access token with the `admin:org` scope to use this endpoint.
+         */
+        setCodespacesBillingUsers: {
+            (params?: RestEndpointMethodTypes["codespaces"]["setCodespacesBillingUsers"]["parameters"]): Promise<RestEndpointMethodTypes["codespaces"]["setCodespacesBillingUsers"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Select the repositories that will use a user's codespace secret.
          *
@@ -3648,28 +4087,29 @@ export declare type RestEndpointMethods = {
          *
          * #### Example encrypting a secret using Node.js
          *
-         * Encrypt your secret using the [tweetsodium](https://github.com/github/tweetsodium) library.
+         * Encrypt your secret using the [libsodium-wrappers](https://www.npmjs.com/package/libsodium-wrappers) library.
          *
          * ```
-         * const sodium = require('tweetsodium');
+         * const sodium = require('libsodium-wrappers')
+         * const secret = 'plain-text-secret' // replace with the secret you want to encrypt
+         * const key = 'base64-encoded-public-key' // replace with the Base64 encoded public key
          *
-         * const key = "base64-encoded-public-key";
-         * const value = "plain-text-secret";
-         *
-         * // Convert the message and key to Uint8Array's (Buffer implements that interface)
-         * const messageBytes = Buffer.from(value);
-         * const keyBytes = Buffer.from(key, 'base64');
+         * //Check if libsodium is ready and then proceed.
+         * sodium.ready.then(() => {
+         *   // Convert Secret & Base64 key to Uint8Array.
+         *   let binkey = sodium.from_base64(key, sodium.base64_variants.ORIGINAL)
+         *   let binsec = sodium.from_string(secret)
          *
-         * // Encrypt using LibSodium.
-         * const encryptedBytes = sodium.seal(messageBytes, keyBytes);
+         *   //Encrypt the secret using LibSodium
+         *   let encBytes = sodium.crypto_box_seal(binsec, binkey)
          *
-         * // Base64 the encrypted secret
-         * const encrypted = Buffer.from(encryptedBytes).toString('base64');
+         *   // Convert encrypted Uint8Array to Base64
+         *   let output = sodium.to_base64(encBytes, sodium.base64_variants.ORIGINAL)
          *
-         * console.log(encrypted);
+         *   console.log(output)
+         * });
          * ```
          *
-         *
          * #### Example encrypting a secret using Python
          *
          * Encrypt your secret using [pynacl](https://pynacl.readthedocs.io/en/latest/public/#nacl-public-sealedbox) with Python 3.
@@ -3747,340 +4187,197 @@ export declare type RestEndpointMethods = {
         /**
          * You must use an access token with the `security_events` scope to use this endpoint with private repositories.
          * You can also use tokens with the `public_repo` scope for public repositories only.
-         * GitHub Apps must have **Dependabot alerts** read permission to use this endpoint.
-         */
-        getAlert: {
-            (params?: RestEndpointMethodTypes["dependabot"]["getAlert"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getAlert"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Gets your public key, which you need to encrypt secrets. You need to encrypt a secret before you can create or update secrets. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
-         */
-        getOrgPublicKey: {
-            (params?: RestEndpointMethodTypes["dependabot"]["getOrgPublicKey"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getOrgPublicKey"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Gets a single organization secret without revealing its encrypted value. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
-         */
-        getOrgSecret: {
-            (params?: RestEndpointMethodTypes["dependabot"]["getOrgSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getOrgSecret"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Gets your public key, which you need to encrypt secrets. You need to encrypt a secret before you can create or update secrets. Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. GitHub Apps must have the `dependabot_secrets` repository permission to use this endpoint.
-         */
-        getRepoPublicKey: {
-            (params?: RestEndpointMethodTypes["dependabot"]["getRepoPublicKey"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getRepoPublicKey"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Gets a single repository secret without revealing its encrypted value. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` repository permission to use this endpoint.
-         */
-        getRepoSecret: {
-            (params?: RestEndpointMethodTypes["dependabot"]["getRepoSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getRepoSecret"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * You must use an access token with the `security_events` scope to use this endpoint with private repositories.
-         * You can also use tokens with the `public_repo` scope for public repositories only.
-         * GitHub Apps must have **Dependabot alerts** read permission to use this endpoint.
-         */
-        listAlertsForRepo: {
-            (params?: RestEndpointMethodTypes["dependabot"]["listAlertsForRepo"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listAlertsForRepo"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Lists all secrets available in an organization without revealing their encrypted values. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
-         */
-        listOrgSecrets: {
-            (params?: RestEndpointMethodTypes["dependabot"]["listOrgSecrets"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listOrgSecrets"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Lists all secrets available in a repository without revealing their encrypted values. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` repository permission to use this endpoint.
-         */
-        listRepoSecrets: {
-            (params?: RestEndpointMethodTypes["dependabot"]["listRepoSecrets"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listRepoSecrets"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Lists all repositories that have been selected when the `visibility` for repository access to a secret is set to `selected`. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
-         */
-        listSelectedReposForOrgSecret: {
-            (params?: RestEndpointMethodTypes["dependabot"]["listSelectedReposForOrgSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listSelectedReposForOrgSecret"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Removes a repository from an organization secret when the `visibility` for repository access is set to `selected`. The visibility is set when you [Create or update an organization secret](https://docs.github.com/rest/reference/dependabot#create-or-update-an-organization-secret). You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
-         */
-        removeSelectedRepoFromOrgSecret: {
-            (params?: RestEndpointMethodTypes["dependabot"]["removeSelectedRepoFromOrgSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["removeSelectedRepoFromOrgSecret"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * Replaces all repositories for an organization secret when the `visibility` for repository access is set to `selected`. The visibility is set when you [Create or update an organization secret](https://docs.github.com/rest/reference/dependabot#create-or-update-an-organization-secret). You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
-         */
-        setSelectedReposForOrgSecret: {
-            (params?: RestEndpointMethodTypes["dependabot"]["setSelectedReposForOrgSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["setSelectedReposForOrgSecret"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
-        /**
-         * You must use an access token with the `security_events` scope to use this endpoint with private repositories.
-         * You can also use tokens with the `public_repo` scope for public repositories only.
-         * GitHub Apps must have **Dependabot alerts** write permission to use this endpoint.
+         * GitHub Apps must have **Dependabot alerts** read permission to use this endpoint.
          */
-        updateAlert: {
-            (params?: RestEndpointMethodTypes["dependabot"]["updateAlert"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["updateAlert"]["response"]>;
+        getAlert: {
+            (params?: RestEndpointMethodTypes["dependabot"]["getAlert"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getAlert"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
-    };
-    dependencyGraph: {
         /**
-         * Create a new snapshot of a repository's dependencies. You must authenticate using an access token with the `repo` scope to use this endpoint for a repository that the requesting user has access to.
+         * Gets your public key, which you need to encrypt secrets. You need to encrypt a secret before you can create or update secrets. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
          */
-        createRepositorySnapshot: {
-            (params?: RestEndpointMethodTypes["dependencyGraph"]["createRepositorySnapshot"]["parameters"]): Promise<RestEndpointMethodTypes["dependencyGraph"]["createRepositorySnapshot"]["response"]>;
+        getOrgPublicKey: {
+            (params?: RestEndpointMethodTypes["dependabot"]["getOrgPublicKey"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getOrgPublicKey"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Gets the diff of the dependency changes between two commits of a repository, based on the changes to the dependency manifests made in those commits.
+         * Gets a single organization secret without revealing its encrypted value. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
          */
-        diffRange: {
-            (params?: RestEndpointMethodTypes["dependencyGraph"]["diffRange"]["parameters"]): Promise<RestEndpointMethodTypes["dependencyGraph"]["diffRange"]["response"]>;
+        getOrgSecret: {
+            (params?: RestEndpointMethodTypes["dependabot"]["getOrgSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getOrgSecret"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
-    };
-    emojis: {
         /**
-         * Lists all the emojis available to use on GitHub.
+         * Gets your public key, which you need to encrypt secrets. You need to encrypt a secret before you can create or update secrets. Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the `repo` scope. GitHub Apps must have the `dependabot_secrets` repository permission to use this endpoint.
          */
-        get: {
-            (params?: RestEndpointMethodTypes["emojis"]["get"]["parameters"]): Promise<RestEndpointMethodTypes["emojis"]["get"]["response"]>;
+        getRepoPublicKey: {
+            (params?: RestEndpointMethodTypes["dependabot"]["getRepoPublicKey"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getRepoPublicKey"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
-    };
-    enterpriseAdmin: {
         /**
-         * Add custom labels to a self-hosted runner configured in an enterprise.
-         *
-         * You must authenticate using an access token with the `manage_runners:enterprise` scope to use this endpoint.
+         * Gets a single repository secret without revealing its encrypted value. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` repository permission to use this endpoint.
          */
-        addCustomLabelsToSelfHostedRunnerForEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["addCustomLabelsToSelfHostedRunnerForEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["addCustomLabelsToSelfHostedRunnerForEnterprise"]["response"]>;
+        getRepoSecret: {
+            (params?: RestEndpointMethodTypes["dependabot"]["getRepoSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["getRepoSecret"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Removes an organization from the list of selected organizations that are enabled for GitHub Actions in an enterprise. To use this endpoint, the enterprise permission policy for `enabled_organizations` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for an enterprise](#set-github-actions-permissions-for-an-enterprise)."
-         *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
+         * Lists Dependabot alerts for repositories that are owned by the specified enterprise.
+         * To use this endpoint, you must be a member of the enterprise, and you must use an
+         * access token with the `repo` scope or `security_events` scope.
+         * Alerts are only returned for organizations in the enterprise for which you are an organization owner or a security manager. For more information about security managers, see "[Managing security managers in your organization](https://docs.github.com/organizations/managing-peoples-access-to-your-organization-with-roles/managing-security-managers-in-your-organization)."
          */
-        disableSelectedOrganizationGithubActionsEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["disableSelectedOrganizationGithubActionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["disableSelectedOrganizationGithubActionsEnterprise"]["response"]>;
+        listAlertsForEnterprise: {
+            (params?: RestEndpointMethodTypes["dependabot"]["listAlertsForEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listAlertsForEnterprise"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Adds an organization to the list of selected organizations that are enabled for GitHub Actions in an enterprise. To use this endpoint, the enterprise permission policy for `enabled_organizations` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for an enterprise](#set-github-actions-permissions-for-an-enterprise)."
+         * Lists Dependabot alerts for an organization.
+         *
+         * To use this endpoint, you must be an owner or security manager for the organization, and you must use an access token with the `repo` scope or `security_events` scope.
+         *
+         * For public repositories, you may instead use the `public_repo` scope.
          *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
+         * GitHub Apps must have **Dependabot alerts** read permission to use this endpoint.
          */
-        enableSelectedOrganizationGithubActionsEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["enableSelectedOrganizationGithubActionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["enableSelectedOrganizationGithubActionsEnterprise"]["response"]>;
+        listAlertsForOrg: {
+            (params?: RestEndpointMethodTypes["dependabot"]["listAlertsForOrg"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listAlertsForOrg"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Gets the selected actions and reusable workflows that are allowed in an enterprise. To use this endpoint, the enterprise permission policy for `allowed_actions` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for an enterprise](#set-github-actions-permissions-for-an-enterprise)."
-         *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
+         * You must use an access token with the `security_events` scope to use this endpoint with private repositories.
+         * You can also use tokens with the `public_repo` scope for public repositories only.
+         * GitHub Apps must have **Dependabot alerts** read permission to use this endpoint.
          */
-        getAllowedActionsEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["getAllowedActionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["getAllowedActionsEnterprise"]["response"]>;
+        listAlertsForRepo: {
+            (params?: RestEndpointMethodTypes["dependabot"]["listAlertsForRepo"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listAlertsForRepo"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Gets the GitHub Actions permissions policy for organizations and allowed actions and reusable workflows in an enterprise.
-         *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
+         * Lists all secrets available in an organization without revealing their encrypted values. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
          */
-        getGithubActionsPermissionsEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["getGithubActionsPermissionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["getGithubActionsPermissionsEnterprise"]["response"]>;
+        listOrgSecrets: {
+            (params?: RestEndpointMethodTypes["dependabot"]["listOrgSecrets"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listOrgSecrets"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Returns aggregate usage metrics for your GitHub Enterprise Server 3.5+ instance for a specified time period up to 365 days.
-         *
-         * To use this endpoint, your GitHub Enterprise Server instance must be connected to GitHub Enterprise Cloud using GitHub Connect. You must enable Server Statistics, and for the API request provide your enterprise account name or organization name connected to the GitHub Enterprise Server. For more information, see "[Enabling Server Statistics for your enterprise](/admin/configuration/configuring-github-connect/enabling-server-statistics-for-your-enterprise)" in the GitHub Enterprise Server documentation.
-         *
-         * You'll need to use a personal access token:
-         *   - If you connected your GitHub Enterprise Server to an enterprise account and enabled Server Statistics, you'll need a personal access token with the `read:enterprise` permission.
-         *   - If you connected your GitHub Enterprise Server to an organization account and enabled Server Statistics, you'll need a personal access token with the `read:org` permission.
-         *
-         * For more information on creating a personal access token, see "[Creating a personal access token](/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token)."
+         * Lists all secrets available in a repository without revealing their encrypted values. You must authenticate using an access token with the `repo` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` repository permission to use this endpoint.
          */
-        getServerStatistics: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["getServerStatistics"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["getServerStatistics"]["response"]>;
+        listRepoSecrets: {
+            (params?: RestEndpointMethodTypes["dependabot"]["listRepoSecrets"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listRepoSecrets"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Lists all labels for a self-hosted runner configured in an enterprise.
-         *
-         * You must authenticate using an access token with the `manage_runners:enterprise` scope to use this endpoint.
+         * Lists all repositories that have been selected when the `visibility` for repository access to a secret is set to `selected`. You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
          */
-        listLabelsForSelfHostedRunnerForEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["listLabelsForSelfHostedRunnerForEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["listLabelsForSelfHostedRunnerForEnterprise"]["response"]>;
+        listSelectedReposForOrgSecret: {
+            (params?: RestEndpointMethodTypes["dependabot"]["listSelectedReposForOrgSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["listSelectedReposForOrgSecret"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Lists the organizations that are selected to have GitHub Actions enabled in an enterprise. To use this endpoint, the enterprise permission policy for `enabled_organizations` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for an enterprise](#set-github-actions-permissions-for-an-enterprise)."
-         *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
+         * Removes a repository from an organization secret when the `visibility` for repository access is set to `selected`. The visibility is set when you [Create or update an organization secret](https://docs.github.com/rest/reference/dependabot#create-or-update-an-organization-secret). You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
          */
-        listSelectedOrganizationsEnabledGithubActionsEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["listSelectedOrganizationsEnabledGithubActionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["listSelectedOrganizationsEnabledGithubActionsEnterprise"]["response"]>;
+        removeSelectedRepoFromOrgSecret: {
+            (params?: RestEndpointMethodTypes["dependabot"]["removeSelectedRepoFromOrgSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["removeSelectedRepoFromOrgSecret"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Remove all custom labels from a self-hosted runner configured in an
-         * enterprise. Returns the remaining read-only labels from the runner.
-         *
-         * You must authenticate using an access token with the `manage_runners:enterprise` scope to use this endpoint.
+         * Replaces all repositories for an organization secret when the `visibility` for repository access is set to `selected`. The visibility is set when you [Create or update an organization secret](https://docs.github.com/rest/reference/dependabot#create-or-update-an-organization-secret). You must authenticate using an access token with the `admin:org` scope to use this endpoint. GitHub Apps must have the `dependabot_secrets` organization permission to use this endpoint.
          */
-        removeAllCustomLabelsFromSelfHostedRunnerForEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["removeAllCustomLabelsFromSelfHostedRunnerForEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["removeAllCustomLabelsFromSelfHostedRunnerForEnterprise"]["response"]>;
+        setSelectedReposForOrgSecret: {
+            (params?: RestEndpointMethodTypes["dependabot"]["setSelectedReposForOrgSecret"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["setSelectedReposForOrgSecret"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Remove a custom label from a self-hosted runner configured
-         * in an enterprise. Returns the remaining labels from the runner.
-         *
-         * This endpoint returns a `404 Not Found` status if the custom label is not
-         * present on the runner.
-         *
-         * You must authenticate using an access token with the `manage_runners:enterprise` scope to use this endpoint.
+         * You must use an access token with the `security_events` scope to use this endpoint with private repositories.
+         * You can also use tokens with the `public_repo` scope for public repositories only.
+         * GitHub Apps must have **Dependabot alerts** write permission to use this endpoint.
          */
-        removeCustomLabelFromSelfHostedRunnerForEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["removeCustomLabelFromSelfHostedRunnerForEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["removeCustomLabelFromSelfHostedRunnerForEnterprise"]["response"]>;
+        updateAlert: {
+            (params?: RestEndpointMethodTypes["dependabot"]["updateAlert"]["parameters"]): Promise<RestEndpointMethodTypes["dependabot"]["updateAlert"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
+    };
+    dependencyGraph: {
         /**
-         * Sets the actions and reusable workflows that are allowed in an enterprise. To use this endpoint, the enterprise permission policy for `allowed_actions` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for an enterprise](#set-github-actions-permissions-for-an-enterprise)."
-         *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
+         * Create a new snapshot of a repository's dependencies. You must authenticate using an access token with the `repo` scope to use this endpoint for a repository that the requesting user has access to.
          */
-        setAllowedActionsEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["setAllowedActionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["setAllowedActionsEnterprise"]["response"]>;
+        createRepositorySnapshot: {
+            (params?: RestEndpointMethodTypes["dependencyGraph"]["createRepositorySnapshot"]["parameters"]): Promise<RestEndpointMethodTypes["dependencyGraph"]["createRepositorySnapshot"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Remove all previous custom labels and set the new custom labels for a specific
-         * self-hosted runner configured in an enterprise.
-         *
-         * You must authenticate using an access token with the `manage_runners:enterprise` scope to use this endpoint.
+         * Gets the diff of the dependency changes between two commits of a repository, based on the changes to the dependency manifests made in those commits.
          */
-        setCustomLabelsForSelfHostedRunnerForEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["setCustomLabelsForSelfHostedRunnerForEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["setCustomLabelsForSelfHostedRunnerForEnterprise"]["response"]>;
+        diffRange: {
+            (params?: RestEndpointMethodTypes["dependencyGraph"]["diffRange"]["parameters"]): Promise<RestEndpointMethodTypes["dependencyGraph"]["diffRange"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
         /**
-         * Sets the GitHub Actions permissions policy for organizations and allowed actions and reusable workflows in an enterprise.
-         *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
+         * Exports the software bill of materials (SBOM) for a repository in SPDX JSON format.
          */
-        setGithubActionsPermissionsEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["setGithubActionsPermissionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["setGithubActionsPermissionsEnterprise"]["response"]>;
+        exportSbom: {
+            (params?: RestEndpointMethodTypes["dependencyGraph"]["exportSbom"]["parameters"]): Promise<RestEndpointMethodTypes["dependencyGraph"]["exportSbom"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
+    };
+    emojis: {
         /**
-         * Replaces the list of selected organizations that are enabled for GitHub Actions in an enterprise. To use this endpoint, the enterprise permission policy for `enabled_organizations` must be configured to `selected`. For more information, see "[Set GitHub Actions permissions for an enterprise](#set-github-actions-permissions-for-an-enterprise)."
-         *
-         * You must authenticate using an access token with the `admin:enterprise` scope to use this endpoint.
+         * Lists all the emojis available to use on GitHub.
          */
-        setSelectedOrganizationsEnabledGithubActionsEnterprise: {
-            (params?: RestEndpointMethodTypes["enterpriseAdmin"]["setSelectedOrganizationsEnabledGithubActionsEnterprise"]["parameters"]): Promise<RestEndpointMethodTypes["enterpriseAdmin"]["setSelectedOrganizationsEnabledGithubActionsEnterprise"]["response"]>;
+        get: {
+            (params?: RestEndpointMethodTypes["emojis"]["get"]["parameters"]): Promise<RestEndpointMethodTypes["emojis"]["get"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
@@ -4237,7 +4534,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Allows you to update or delete a gist file and rename gist files. Files from the previous version of the gist that aren't explicitly changed during an edit are unchanged.
+         * Allows you to update a gist's description and to update, delete, or rename gist files. Files from the previous version of the gist that aren't explicitly changed during an edit are unchanged.
          */
         update: {
             (params?: RestEndpointMethodTypes["gists"]["update"]["parameters"]): Promise<RestEndpointMethodTypes["gists"]["update"]["response"]>;
@@ -4287,7 +4584,7 @@ export declare type RestEndpointMethods = {
          * | `unsigned` | The object does not include a signature. |
          * | `unknown_signature_type` | A non-PGP signature was found in the commit. |
          * | `no_user` | No user was associated with the `committer` email address in the commit. |
-         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on her/his account. |
+         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
          * | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
          * | `unknown_key` | The key that made the signature has not been registered with any user's account. |
          * | `malformed_signature` | There was an error parsing the signature. |
@@ -4336,7 +4633,7 @@ export declare type RestEndpointMethods = {
          * | `unsigned` | The object does not include a signature. |
          * | `unknown_signature_type` | A non-PGP signature was found in the commit. |
          * | `no_user` | No user was associated with the `committer` email address in the commit. |
-         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on her/his account. |
+         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
          * | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
          * | `unknown_key` | The key that made the signature has not been registered with any user's account. |
          * | `malformed_signature` | There was an error parsing the signature. |
@@ -4408,7 +4705,7 @@ export declare type RestEndpointMethods = {
          * | `unsigned` | The object does not include a signature. |
          * | `unknown_signature_type` | A non-PGP signature was found in the commit. |
          * | `no_user` | No user was associated with the `committer` email address in the commit. |
-         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on her/his account. |
+         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
          * | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
          * | `unknown_key` | The key that made the signature has not been registered with any user's account. |
          * | `malformed_signature` | There was an error parsing the signature. |
@@ -4457,7 +4754,7 @@ export declare type RestEndpointMethods = {
          * | `unsigned` | The object does not include a signature. |
          * | `unknown_signature_type` | A non-PGP signature was found in the commit. |
          * | `no_user` | No user was associated with the `committer` email address in the commit. |
-         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on her/his account. |
+         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
          * | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
          * | `unknown_key` | The key that made the signature has not been registered with any user's account. |
          * | `malformed_signature` | There was an error parsing the signature. |
@@ -4690,6 +4987,20 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Checks if a user has permission to be assigned to a specific issue.
+         *
+         * If the `assignee` can be assigned to this issue, a `204` status code with no content is returned.
+         *
+         * Otherwise a `404` status code is returned.
+         */
+        checkUserCanBeAssignedToIssue: {
+            (params?: RestEndpointMethodTypes["issues"]["checkUserCanBeAssignedToIssue"]["parameters"]): Promise<RestEndpointMethodTypes["issues"]["checkUserCanBeAssignedToIssue"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Any user with pull access to a repository can create an issue. If [issues are disabled in the repository](https://docs.github.com/articles/disabling-issues/), the API returns a `410 Gone` status.
          *
@@ -4703,7 +5014,13 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
+         * You can use the REST API to create comments on issues and pull requests. Every pull request is an issue, but not every issue is a pull request.
+         *
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications).
+         * Creating content too quickly using this endpoint may result in secondary rate limiting.
+         * See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)"
+         * and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)"
+         * for details.
          */
         createComment: {
             (params?: RestEndpointMethodTypes["issues"]["createComment"]["parameters"]): Promise<RestEndpointMethodTypes["issues"]["createComment"]["response"]>;
@@ -4726,6 +5043,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * You can use the REST API to delete comments on issues and pull requests. Every pull request is an issue, but not every issue is a pull request.
+         */
         deleteComment: {
             (params?: RestEndpointMethodTypes["issues"]["deleteComment"]["parameters"]): Promise<RestEndpointMethodTypes["issues"]["deleteComment"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -4755,7 +5075,7 @@ export declare type RestEndpointMethods = {
          * access, the API returns a `410 Gone` status. To receive webhook events for transferred and deleted issues, subscribe
          * to the [`issues`](https://docs.github.com/webhooks/event-payloads/#issues) webhook.
          *
-         * **Note**: GitHub's REST API v3 considers every pull request an issue, but not every issue is a pull request. For this
+         * **Note**: GitHub's REST API considers every pull request an issue, but not every issue is a pull request. For this
          * reason, "Issues" endpoints may return both issues and pull requests in the response. You can identify pull requests by
          * the `pull_request` key. Be aware that the `id` of a pull request returned from "Issues" endpoints will be an _issue id_. To find out the pull
          * request id, use the "[List pull requests](https://docs.github.com/rest/reference/pulls#list-pull-requests)" endpoint.
@@ -4767,6 +5087,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * You can use the REST API to get comments on issues and pull requests. Every pull request is an issue, but not every issue is a pull request.
+         */
         getComment: {
             (params?: RestEndpointMethodTypes["issues"]["getComment"]["parameters"]): Promise<RestEndpointMethodTypes["issues"]["getComment"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -4801,7 +5124,7 @@ export declare type RestEndpointMethods = {
          * necessarily assigned to you.
          *
          *
-         * **Note**: GitHub's REST API v3 considers every pull request an issue, but not every issue is a pull request. For this
+         * **Note**: GitHub's REST API considers every pull request an issue, but not every issue is a pull request. For this
          * reason, "Issues" endpoints may return both issues and pull requests in the response. You can identify pull requests by
          * the `pull_request` key. Be aware that the `id` of a pull request returned from "Issues" endpoints will be an _issue id_. To find out the pull
          * request id, use the "[List pull requests](https://docs.github.com/rest/reference/pulls#list-pull-requests)" endpoint.
@@ -4824,7 +5147,9 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Issue Comments are ordered by ascending ID.
+         * You can use the REST API to list comments on issues and pull requests. Every pull request is an issue, but not every issue is a pull request.
+         *
+         * Issue comments are ordered by ascending ID.
          */
         listComments: {
             (params?: RestEndpointMethodTypes["issues"]["listComments"]["parameters"]): Promise<RestEndpointMethodTypes["issues"]["listComments"]["response"]>;
@@ -4834,7 +5159,9 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * By default, Issue Comments are ordered by ascending ID.
+         * You can use the REST API to list comments on issues and pull requests for a repository. Every pull request is an issue, but not every issue is a pull request.
+         *
+         * By default, issue comments are ordered by ascending ID.
          */
         listCommentsForRepo: {
             (params?: RestEndpointMethodTypes["issues"]["listCommentsForRepo"]["parameters"]): Promise<RestEndpointMethodTypes["issues"]["listCommentsForRepo"]["response"]>;
@@ -4867,7 +5194,7 @@ export declare type RestEndpointMethods = {
         /**
          * List issues across owned and member repositories assigned to the authenticated user.
          *
-         * **Note**: GitHub's REST API v3 considers every pull request an issue, but not every issue is a pull request. For this
+         * **Note**: GitHub's REST API considers every pull request an issue, but not every issue is a pull request. For this
          * reason, "Issues" endpoints may return both issues and pull requests in the response. You can identify pull requests by
          * the `pull_request` key. Be aware that the `id` of a pull request returned from "Issues" endpoints will be an _issue id_. To find out the pull
          * request id, use the "[List pull requests](https://docs.github.com/rest/reference/pulls#list-pull-requests)" endpoint.
@@ -4882,7 +5209,7 @@ export declare type RestEndpointMethods = {
         /**
          * List issues in an organization assigned to the authenticated user.
          *
-         * **Note**: GitHub's REST API v3 considers every pull request an issue, but not every issue is a pull request. For this
+         * **Note**: GitHub's REST API considers every pull request an issue, but not every issue is a pull request. For this
          * reason, "Issues" endpoints may return both issues and pull requests in the response. You can identify pull requests by
          * the `pull_request` key. Be aware that the `id` of a pull request returned from "Issues" endpoints will be an _issue id_. To find out the pull
          * request id, use the "[List pull requests](https://docs.github.com/rest/reference/pulls#list-pull-requests)" endpoint.
@@ -4895,9 +5222,9 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * List issues in a repository.
+         * List issues in a repository. Only open issues will be listed.
          *
-         * **Note**: GitHub's REST API v3 considers every pull request an issue, but not every issue is a pull request. For this
+         * **Note**: GitHub's REST API considers every pull request an issue, but not every issue is a pull request. For this
          * reason, "Issues" endpoints may return both issues and pull requests in the response. You can identify pull requests by
          * the `pull_request` key. Be aware that the `id` of a pull request returned from "Issues" endpoints will be an _issue id_. To find out the pull
          * request id, use the "[List pull requests](https://docs.github.com/rest/reference/pulls#list-pull-requests)" endpoint.
@@ -5006,6 +5333,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * You can use the REST API to update comments on issues and pull requests. Every pull request is an issue, but not every issue is a pull request.
+         */
         updateComment: {
             (params?: RestEndpointMethodTypes["issues"]["updateComment"]["parameters"]): Promise<RestEndpointMethodTypes["issues"]["updateComment"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -5079,7 +5409,9 @@ export declare type RestEndpointMethods = {
         /**
          * Returns meta information about GitHub, including a list of GitHub's IP addresses. For more information, see "[About GitHub's IP addresses](https://docs.github.com/articles/about-github-s-ip-addresses/)."
          *
-         * **Note:** The IP addresses shown in the documentation's response are only example values. You must always query the API directly to get the latest list of IP addresses.
+         * The values shown in the documentation's response are example values. You must always query the API directly to get the latest values.
+         *
+         * **Note:** This endpoint returns both IPv4 and IPv6 addresses. However, not all features support IPv6. You should refer to the specific documentation for each feature to determine if IPv6 is supported.
          */
         get: {
             (params?: RestEndpointMethodTypes["meta"]["get"]["parameters"]): Promise<RestEndpointMethodTypes["meta"]["get"]["response"]>;
@@ -5088,6 +5420,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Get all supported GitHub API versions.
+         */
+        getAllVersions: {
+            (params?: RestEndpointMethodTypes["meta"]["getAllVersions"]["parameters"]): Promise<RestEndpointMethodTypes["meta"]["getAllVersions"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Get the octocat as ASCII art
          */
@@ -5122,6 +5464,10 @@ export declare type RestEndpointMethods = {
     migrations: {
         /**
          * Stop an import for a repository.
+         *
+         * **Warning:** Support for importing Mercurial, Subversion and Team Foundation Version Control repositories will end
+         * on October 17, 2023. For more details, see [changelog](https://gh.io/github-importer-non-git-eol). In the coming weeks, we will update
+         * these docs to reflect relevant changes to the API and will contact all integrators using the "Source imports" API.
          */
         cancelImport: {
             (params?: RestEndpointMethodTypes["migrations"]["cancelImport"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["cancelImport"]["response"]>;
@@ -5131,7 +5477,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Deletes a previous migration archive. Downloadable migration archives are automatically deleted after seven days. Migration metadata, which is returned in the [List user migrations](https://docs.github.com/rest/reference/migrations#list-user-migrations) and [Get a user migration status](https://docs.github.com/rest/reference/migrations#get-a-user-migration-status) endpoints, will continue to be available even after an archive is deleted.
+         * Deletes a previous migration archive. Downloadable migration archives are automatically deleted after seven days. Migration metadata, which is returned in the [List user migrations](https://docs.github.com/rest/migrations/users#list-user-migrations) and [Get a user migration status](https://docs.github.com/rest/migrations/users#get-a-user-migration-status) endpoints, will continue to be available even after an archive is deleted.
          */
         deleteArchiveForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["migrations"]["deleteArchiveForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["deleteArchiveForAuthenticatedUser"]["response"]>;
@@ -5193,7 +5539,11 @@ export declare type RestEndpointMethods = {
         /**
          * Each type of source control system represents authors in a different way. For example, a Git commit author has a display name and an email address, but a Subversion commit author just has a username. The GitHub Importer will make the author information valid, but the author might not be correct. For example, it will change the bare Subversion username `hubot` into something like `hubot <hubot@12341234-abab-fefe-8787-fedcba987654>`.
          *
-         * This endpoint and the [Map a commit author](https://docs.github.com/rest/reference/migrations#map-a-commit-author) endpoint allow you to provide correct Git author information.
+         * This endpoint and the [Map a commit author](https://docs.github.com/rest/migrations/source-imports#map-a-commit-author) endpoint allow you to provide correct Git author information.
+         *
+         * **Warning:** Support for importing Mercurial, Subversion and Team Foundation Version Control repositories will end
+         * on October 17, 2023. For more details, see [changelog](https://gh.io/github-importer-non-git-eol). In the coming weeks, we will update
+         * these docs to reflect relevant changes to the API and will contact all integrators using the "Source imports" API.
          */
         getCommitAuthors: {
             (params?: RestEndpointMethodTypes["migrations"]["getCommitAuthors"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["getCommitAuthors"]["response"]>;
@@ -5205,6 +5555,10 @@ export declare type RestEndpointMethods = {
         /**
          * View the progress of an import.
          *
+         * **Warning:** Support for importing Mercurial, Subversion and Team Foundation Version Control repositories will end
+         * on October 17, 2023. For more details, see [changelog](https://gh.io/github-importer-non-git-eol). In the coming weeks, we will update
+         * these docs to reflect relevant changes to the API and will contact all integrators using the "Source imports" API.
+         *
          * **Import status**
          *
          * This section includes details about the possible values of the `status` field of the Import Progress response.
@@ -5219,11 +5573,11 @@ export declare type RestEndpointMethods = {
          *
          * If there are problems, you will see one of these in the `status` field:
          *
-         * *   `auth_failed` - the import requires authentication in order to connect to the original repository. To update authentication for the import, please see the [Update an import](https://docs.github.com/rest/reference/migrations#update-an-import) section.
+         * *   `auth_failed` - the import requires authentication in order to connect to the original repository. To update authentication for the import, please see the [Update an import](https://docs.github.com/rest/migrations/source-imports#update-an-import) section.
          * *   `error` - the import encountered an error. The import progress response will include the `failed_step` and an error message. Contact [GitHub Support](https://support.github.com/contact?tags=dotcom-rest-api) for more information.
-         * *   `detection_needs_auth` - the importer requires authentication for the originating repository to continue detection. To update authentication for the import, please see the [Update an import](https://docs.github.com/rest/reference/migrations#update-an-import) section.
-         * *   `detection_found_nothing` - the importer didn't recognize any source control at the URL. To resolve, [Cancel the import](https://docs.github.com/rest/reference/migrations#cancel-an-import) and [retry](https://docs.github.com/rest/reference/migrations#start-an-import) with the correct URL.
-         * *   `detection_found_multiple` - the importer found several projects or repositories at the provided URL. When this is the case, the Import Progress response will also include a `project_choices` field with the possible project choices as values. To update project choice, please see the [Update an import](https://docs.github.com/rest/reference/migrations#update-an-import) section.
+         * *   `detection_needs_auth` - the importer requires authentication for the originating repository to continue detection. To update authentication for the import, please see the [Update an import](https://docs.github.com/rest/migrations/source-imports#update-an-import) section.
+         * *   `detection_found_nothing` - the importer didn't recognize any source control at the URL. To resolve, [Cancel the import](https://docs.github.com/rest/migrations/source-imports#cancel-an-import) and [retry](https://docs.github.com/rest/migrations/source-imports#start-an-import) with the correct URL.
+         * *   `detection_found_multiple` - the importer found several projects or repositories at the provided URL. When this is the case, the Import Progress response will also include a `project_choices` field with the possible project choices as values. To update project choice, please see the [Update an import](https://docs.github.com/rest/migrations/source-imports#update-an-import) section.
          *
          * **The project_choices field**
          *
@@ -5247,6 +5601,10 @@ export declare type RestEndpointMethods = {
         };
         /**
          * List files larger than 100MB found during the import
+         *
+         * **Warning:** Support for importing Mercurial, Subversion and Team Foundation Version Control repositories will end
+         * on October 17, 2023. For more details, see [changelog](https://gh.io/github-importer-non-git-eol). In the coming weeks, we will update
+         * these docs to reflect relevant changes to the API and will contact all integrators using the "Source imports" API.
          */
         getLargeFiles: {
             (params?: RestEndpointMethodTypes["migrations"]["getLargeFiles"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["getLargeFiles"]["response"]>;
@@ -5263,7 +5621,7 @@ export declare type RestEndpointMethods = {
          * *   `exported` - the migration finished successfully.
          * *   `failed` - the migration failed.
          *
-         * Once the migration has been `exported` you can [download the migration archive](https://docs.github.com/rest/reference/migrations#download-a-user-migration-archive).
+         * Once the migration has been `exported` you can [download the migration archive](https://docs.github.com/rest/migrations/users#download-a-user-migration-archive).
          */
         getStatusForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["migrations"]["getStatusForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["getStatusForAuthenticatedUser"]["response"]>;
@@ -5300,7 +5658,9 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Lists the most recent migrations.
+         * Lists the most recent migrations, including both exports (which can be started through the REST API) and imports (which cannot be started using the REST API).
+         *
+         * A list of `repositories` is only returned for export migrations.
          */
         listForOrg: {
             (params?: RestEndpointMethodTypes["migrations"]["listForOrg"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["listForOrg"]["response"]>;
@@ -5341,7 +5701,12 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Update an author's identity for the import. Your application can continue updating authors any time before you push new commits to the repository.
+         * Update an author's identity for the import. Your application can continue updating authors any time before you push
+         * new commits to the repository.
+         *
+         * **Warning:** Support for importing Mercurial, Subversion and Team Foundation Version Control repositories will end
+         * on October 17, 2023. For more details, see [changelog](https://gh.io/github-importer-non-git-eol). In the coming weeks, we will update
+         * these docs to reflect relevant changes to the API and will contact all integrators using the "Source imports" API.
          */
         mapCommitAuthor: {
             (params?: RestEndpointMethodTypes["migrations"]["mapCommitAuthor"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["mapCommitAuthor"]["response"]>;
@@ -5351,7 +5716,15 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * You can import repositories from Subversion, Mercurial, and TFS that include files larger than 100MB. This ability is powered by [Git LFS](https://git-lfs.github.com). You can learn more about our LFS feature and working with large files [on our help site](https://docs.github.com/articles/versioning-large-files/).
+         * You can import repositories from Subversion, Mercurial, and TFS that include files larger than 100MB. This ability
+         * is powered by [Git LFS](https://git-lfs.com).
+         *
+         * You can learn more about our LFS feature and working with large files [on our help
+         * site](https://docs.github.com/repositories/working-with-files/managing-large-files).
+         *
+         * **Warning:** Support for importing Mercurial, Subversion and Team Foundation Version Control repositories will end
+         * on October 17, 2023. For more details, see [changelog](https://gh.io/github-importer-non-git-eol). In the coming weeks, we will update
+         * these docs to reflect relevant changes to the API and will contact all integrators using the "Source imports" API.
          */
         setLfsPreference: {
             (params?: RestEndpointMethodTypes["migrations"]["setLfsPreference"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["setLfsPreference"]["response"]>;
@@ -5381,7 +5754,8 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Start a source import to a GitHub repository using GitHub Importer.
+         * Start a source import to a GitHub repository using GitHub Importer. Importing into a GitHub repository with GitHub Actions enabled is not supported and will return a status `422 Unprocessable Entity` response.
+         * **Warning:** Support for importing Mercurial, Subversion and Team Foundation Version Control repositories will end on October 17, 2023. For more details, see [changelog](https://gh.io/github-importer-non-git-eol). In the coming weeks, we will update these docs to reflect relevant changes to the API and will contact all integrators using the "Source imports" API.
          */
         startImport: {
             (params?: RestEndpointMethodTypes["migrations"]["startImport"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["startImport"]["response"]>;
@@ -5391,7 +5765,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Unlocks a repository. You can lock repositories when you [start a user migration](https://docs.github.com/rest/reference/migrations#start-a-user-migration). Once the migration is complete you can unlock each repository to begin using it again or [delete the repository](https://docs.github.com/rest/reference/repos#delete-a-repository) if you no longer need the source data. Returns a status of `404 Not Found` if the repository is not locked.
+         * Unlocks a repository. You can lock repositories when you [start a user migration](https://docs.github.com/rest/migrations/users#start-a-user-migration). Once the migration is complete you can unlock each repository to begin using it again or [delete the repository](https://docs.github.com/rest/repos/repos#delete-a-repository) if you no longer need the source data. Returns a status of `404 Not Found` if the repository is not locked.
          */
         unlockRepoForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["migrations"]["unlockRepoForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["unlockRepoForAuthenticatedUser"]["response"]>;
@@ -5401,7 +5775,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Unlocks a repository that was locked for migration. You should unlock each migrated repository and [delete them](https://docs.github.com/rest/reference/repos#delete-a-repository) when the migration is complete and you no longer need the source data.
+         * Unlocks a repository that was locked for migration. You should unlock each migrated repository and [delete them](https://docs.github.com/rest/repos/repos#delete-a-repository) when the migration is complete and you no longer need the source data.
          */
         unlockRepoForOrg: {
             (params?: RestEndpointMethodTypes["migrations"]["unlockRepoForOrg"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["unlockRepoForOrg"]["response"]>;
@@ -5417,6 +5791,10 @@ export declare type RestEndpointMethods = {
          * Some servers (e.g. TFS servers) can have several projects at a single URL. In those cases the import progress will
          * have the status `detection_found_multiple` and the Import Progress response will include a `project_choices` array.
          * You can select the project to import by providing one of the objects in the `project_choices` array in the update request.
+         *
+         * **Warning:** Support for importing Mercurial, Subversion and Team Foundation Version Control repositories will end
+         * on October 17, 2023. For more details, see [changelog](https://gh.io/github-importer-non-git-eol). In the coming weeks, we will update
+         * these docs to reflect relevant changes to the API and will contact all integrators using the "Source imports" API.
          */
         updateImport: {
             (params?: RestEndpointMethodTypes["migrations"]["updateImport"]["parameters"]): Promise<RestEndpointMethodTypes["migrations"]["updateImport"]["response"]>;
@@ -5451,7 +5829,7 @@ export declare type RestEndpointMethods = {
         /**
          * Cancel an organization invitation. In order to cancel an organization invitation, the authenticated user must be an organization owner.
          *
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications).
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications).
          */
         cancelInvitation: {
             (params?: RestEndpointMethodTypes["orgs"]["cancelInvitation"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["cancelInvitation"]["response"]>;
@@ -5485,7 +5863,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * When an organization member is converted to an outside collaborator, they'll only have access to the repositories that their current team membership allows. The user will no longer be a member of the organization. For more information, see "[Converting an organization member to an outside collaborator](https://docs.github.com/articles/converting-an-organization-member-to-an-outside-collaborator/)". Converting an organization member to an outside collaborator may be restricted by enterprise administrators. For more information, see "[Enforcing repository management policies in your enterprise](https://docs.github.com/enterprise-cloud@latest/admin/policies/enforcing-policies-for-your-enterprise/enforcing-repository-management-policies-in-your-enterprise#enforcing-a-policy-for-inviting-outside-collaborators-to-repositories)."
+         * When an organization member is converted to an outside collaborator, they'll only have access to the repositories that their current team membership allows. The user will no longer be a member of the organization. For more information, see "[Converting an organization member to an outside collaborator](https://docs.github.com/articles/converting-an-organization-member-to-an-outside-collaborator/)". Converting an organization member to an outside collaborator may be restricted by enterprise administrators. For more information, see "[Enforcing repository management policies in your enterprise](https://docs.github.com/admin/policies/enforcing-policies-for-your-enterprise/enforcing-repository-management-policies-in-your-enterprise#enforcing-a-policy-for-inviting-outside-collaborators-to-repositories)."
          */
         convertMemberToOutsideCollaborator: {
             (params?: RestEndpointMethodTypes["orgs"]["convertMemberToOutsideCollaborator"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["convertMemberToOutsideCollaborator"]["response"]>;
@@ -5494,27 +5872,10 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
-        /**
-         * **Note**: This operation is in beta and is subject to change.
-         *
-         * Creates a custom repository role that can be used by all repositories owned by the organization.
-         *
-         * To use this endpoint the authenticated user must be an administrator for the organization and must use an access token with `admin:org` scope.
-         * GitHub Apps must have the `organization_custom_roles:write` organization permission to use this endpoint.
-         *
-         * For more information on custom repository roles, see "[Managing custom repository roles for an organization](https://docs.github.com/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization)."
-         */
-        createCustomRole: {
-            (params?: RestEndpointMethodTypes["orgs"]["createCustomRole"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["createCustomRole"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
         /**
          * Invite people to an organization by using their GitHub user ID or their email address. In order to create invitations in an organization, the authenticated user must be an organization owner.
          *
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          */
         createInvitation: {
             (params?: RestEndpointMethodTypes["orgs"]["createInvitation"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["createInvitation"]["response"]>;
@@ -5534,18 +5895,16 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * **Note**: This operation is in beta and is subject to change.
+         * Deletes an organization and all its repositories.
          *
-         * Deletes a custom role from an organization. Once the custom role has been deleted, any
-         * user, team, or invitation with the deleted custom role will be reassigned the inherited role.
+         * The organization login will be unavailable for 90 days after deletion.
          *
-         * To use this endpoint the authenticated user must be an administrator for the organization and must use an access token with `admin:org` scope.
-         * GitHub Apps must have the `organization_custom_roles:write` organization permission to use this endpoint.
+         * Please review the Terms of Service regarding account deletion before using this endpoint:
          *
-         * For more information about custom repository roles, see "[Managing custom repository roles for an organization](https://docs.github.com/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization)."
+         * https://docs.github.com/site-policy/github-terms/github-terms-of-service
          */
-        deleteCustomRole: {
-            (params?: RestEndpointMethodTypes["orgs"]["deleteCustomRole"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["deleteCustomRole"]["response"]>;
+        delete: {
+            (params?: RestEndpointMethodTypes["orgs"]["delete"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["delete"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
@@ -5559,7 +5918,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Enables or disables the specified security feature for all repositories in an organization.
+         * Enables or disables the specified security feature for all eligible repositories in an organization.
          *
          * To use this endpoint, you must be an organization owner or be member of a team with the security manager role.
          * A token with the 'write:org' scope is also required.
@@ -5639,7 +5998,7 @@ export declare type RestEndpointMethods = {
         /**
          * Lists all organizations, in the order that they were created on GitHub.
          *
-         * **Note:** Pagination is powered exclusively by the `since` parameter. Use the [Link header](https://docs.github.com/rest/overview/resources-in-the-rest-api#link-header) to get the URL for the next page of organizations.
+         * **Note:** Pagination is powered exclusively by the `since` parameter. Use the [Link header](https://docs.github.com/rest/guides/using-pagination-in-the-rest-api#using-link-headers) to get the URL for the next page of organizations.
          */
         list: {
             (params?: RestEndpointMethodTypes["orgs"]["list"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["list"]["response"]>;
@@ -5668,22 +6027,6 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
-        /**
-         * List the custom repository roles available in this organization. In order to see custom
-         * repository roles in an organization, the authenticated user must be an organization owner.
-         *
-         * To use this endpoint the authenticated user must be an administrator for the organization or of an repository of the organizaiton and must use an access token with `admin:org repo` scope.
-         * GitHub Apps must have the `organization_custom_roles:read` organization permission to use this endpoint.
-         *
-         * For more information on custom repository roles, see "[Managing custom repository roles for an organization](https://docs.github.com/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization)".
-         */
-        listCustomRoles: {
-            (params?: RestEndpointMethodTypes["orgs"]["listCustomRoles"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["listCustomRoles"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
         /**
          * The return hash contains `failed_at` and `failed_reason` fields which represent the time at which the invitation failed and the reason for the failure.
          */
@@ -5694,21 +6037,6 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
-        /**
-         * **Note**: This operation is in beta and subject to change.
-         *
-         * Lists the fine-grained permissions available for an organization.
-         *
-         * To use this endpoint the authenticated user must be an administrator for the organization or of an repository of the organizaiton and must use an access token with `admin:org repo` scope.
-         * GitHub Apps must have the `organization_custom_roles:read` organization permission to use this endpoint.
-         */
-        listFineGrainedPermissions: {
-            (params?: RestEndpointMethodTypes["orgs"]["listFineGrainedPermissions"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["listFineGrainedPermissions"]["response"]>;
-            defaults: RequestInterface["defaults"];
-            endpoint: EndpointInterface<{
-                url: string;
-            }>;
-        };
         /**
          * List organizations for the authenticated user.
          *
@@ -5773,7 +6101,59 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * The return hash contains a `role` field which refers to the Organization Invitation role and will be one of the following values: `direct_member`, `admin`, `billing_manager`, `hiring_manager`, or `reinstate`. If the invitee is not a GitHub member, the `login` field in the return hash will be `null`.
+         * Lists the repositories a fine-grained personal access token has access to. Only GitHub Apps can call this API,
+         * using the `organization_personal_access_tokens: read` permission.
+         *
+         * **Note**: Fine-grained PATs are in public beta. Related APIs, events, and functionality are subject to change.
+         */
+        listPatGrantRepositories: {
+            (params?: RestEndpointMethodTypes["orgs"]["listPatGrantRepositories"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["listPatGrantRepositories"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists the repositories a fine-grained personal access token request is requesting access to. Only GitHub Apps can call this API,
+         * using the `organization_personal_access_token_requests: read` permission.
+         *
+         * **Note**: Fine-grained PATs are in public beta. Related APIs, events, and functionality are subject to change.
+         */
+        listPatGrantRequestRepositories: {
+            (params?: RestEndpointMethodTypes["orgs"]["listPatGrantRequestRepositories"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["listPatGrantRequestRepositories"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists requests from organization members to access organization resources with a fine-grained personal access token. Only GitHub Apps can call this API,
+         * using the `organization_personal_access_token_requests: read` permission.
+         *
+         * **Note**: Fine-grained PATs are in public beta. Related APIs, events, and functionality are subject to change.
+         */
+        listPatGrantRequests: {
+            (params?: RestEndpointMethodTypes["orgs"]["listPatGrantRequests"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["listPatGrantRequests"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists approved fine-grained personal access tokens owned by organization members that can access organization resources. Only GitHub Apps can call this API,
+         * using the `organization_personal_access_tokens: read` permission.
+         *
+         * **Note**: Fine-grained PATs are in public beta. Related APIs, events, and functionality are subject to change.
+         */
+        listPatGrants: {
+            (params?: RestEndpointMethodTypes["orgs"]["listPatGrants"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["listPatGrants"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * The return hash contains a `role` field which refers to the Organization Invitation role and will be one of the following values: `direct_member`, `admin`, `billing_manager`, or `hiring_manager`. If the invitee is not a GitHub member, the `login` field in the return hash will be `null`.
          */
         listPendingInvitations: {
             (params?: RestEndpointMethodTypes["orgs"]["listPendingInvitations"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["listPendingInvitations"]["response"]>;
@@ -5896,6 +6276,32 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Approves or denies a pending request to access organization resources via a fine-grained personal access token. Only GitHub Apps can call this API,
+         * using the `organization_personal_access_token_requests: write` permission.
+         *
+         * **Note**: Fine-grained PATs are in public beta. Related APIs, events, and functionality are subject to change.
+         */
+        reviewPatGrantRequest: {
+            (params?: RestEndpointMethodTypes["orgs"]["reviewPatGrantRequest"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["reviewPatGrantRequest"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Approves or denies multiple pending requests to access organization resources via a fine-grained personal access token. Only GitHub Apps can call this API,
+         * using the `organization_personal_access_token_requests: write` permission.
+         *
+         * **Note**: Fine-grained PATs are in public beta. Related APIs, events, and functionality are subject to change.
+         */
+        reviewPatGrantRequestsInBulk: {
+            (params?: RestEndpointMethodTypes["orgs"]["reviewPatGrantRequestsInBulk"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["reviewPatGrantRequestsInBulk"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Only authenticated organization owners can add a member to the organization or update the member's role.
          *
@@ -5945,25 +6351,34 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        updateMembershipForAuthenticatedUser: {
+            (params?: RestEndpointMethodTypes["orgs"]["updateMembershipForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["updateMembershipForAuthenticatedUser"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
-         * **Note**: This operation is in beta and subject to change.
-         *
-         * Updates a custom repository role that can be used by all repositories owned by the organization.
+         * Updates the access an organization member has to organization resources via a fine-grained personal access token. Limited to revoking the token's existing access. Limited to revoking a token's existing access. Only GitHub Apps can call this API,
+         * using the `organization_personal_access_tokens: write` permission.
          *
-         * To use this endpoint the authenticated user must be an administrator for the organization and must use an access token with `admin:org` scope.
-         * GitHub Apps must have the `organization_custom_roles:write` organization permission to use this endpoint.
-         *
-         * For more information about custom repository roles, see "[Managing custom repository roles for an organization](https://docs.github.com/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization)."
+         * **Note**: Fine-grained PATs are in public beta. Related APIs, events, and functionality are subject to change.
          */
-        updateCustomRole: {
-            (params?: RestEndpointMethodTypes["orgs"]["updateCustomRole"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["updateCustomRole"]["response"]>;
+        updatePatAccess: {
+            (params?: RestEndpointMethodTypes["orgs"]["updatePatAccess"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["updatePatAccess"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
             }>;
         };
-        updateMembershipForAuthenticatedUser: {
-            (params?: RestEndpointMethodTypes["orgs"]["updateMembershipForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["updateMembershipForAuthenticatedUser"]["response"]>;
+        /**
+         * Updates the access organization members have to organization resources via fine-grained personal access tokens. Limited to revoking a token's existing access. Only GitHub Apps can call this API,
+         * using the `organization_personal_access_tokens: write` permission.
+         *
+         * **Note**: Fine-grained PATs are in public beta. Related APIs, events, and functionality are subject to change.
+         */
+        updatePatAccesses: {
+            (params?: RestEndpointMethodTypes["orgs"]["updatePatAccesses"]["parameters"]): Promise<RestEndpointMethodTypes["orgs"]["updatePatAccesses"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
@@ -5996,8 +6411,8 @@ export declare type RestEndpointMethods = {
         /**
          * Deletes a package owned by the authenticated user. You cannot delete a public package if any version of the package has more than 5,000 downloads. In this scenario, contact GitHub support for further assistance.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` and `packages:delete` scopes.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` and `delete:packages` scopes.
+         * If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         deletePackageForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["packages"]["deletePackageForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["deletePackageForAuthenticatedUser"]["response"]>;
@@ -6009,9 +6424,9 @@ export declare type RestEndpointMethods = {
         /**
          * Deletes an entire package in an organization. You cannot delete a public package if any version of the package has more than 5,000 downloads. In this scenario, contact GitHub support for further assistance.
          *
-         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `packages:read` and `packages:delete` scopes. In addition:
-         * - If `package_type` is not `container`, your token must also include the `repo` scope.
-         * - If `package_type` is `container`, you must also have admin permissions to the container you want to delete.
+         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `read:packages` and `delete:packages` scopes. In addition:
+         * - If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
+         * - If the `package_type` belongs to a GitHub Packages registry that supports granular permissions, you must have admin permissions to the package you want to delete. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#granular-permissions-for-userorganization-scoped-packages)."
          */
         deletePackageForOrg: {
             (params?: RestEndpointMethodTypes["packages"]["deletePackageForOrg"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["deletePackageForOrg"]["response"]>;
@@ -6023,9 +6438,9 @@ export declare type RestEndpointMethods = {
         /**
          * Deletes an entire package for a user. You cannot delete a public package if any version of the package has more than 5,000 downloads. In this scenario, contact GitHub support for further assistance.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` and `packages:delete` scopes. In addition:
-         * - If `package_type` is not `container`, your token must also include the `repo` scope.
-         * - If `package_type` is `container`, you must also have admin permissions to the container you want to delete.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` and `delete:packages` scopes. In addition:
+         * - If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
+         * - If the `package_type` belongs to a GitHub Packages registry that supports granular permissions, you must have admin permissions to the package you want to delete. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#granular-permissions-for-userorganization-scoped-packages)."
          */
         deletePackageForUser: {
             (params?: RestEndpointMethodTypes["packages"]["deletePackageForUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["deletePackageForUser"]["response"]>;
@@ -6037,8 +6452,8 @@ export declare type RestEndpointMethods = {
         /**
          * Deletes a specific package version for a package owned by the authenticated user.  If the package is public and the package version has more than 5,000 downloads, you cannot delete the package version. In this scenario, contact GitHub support for further assistance.
          *
-         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `packages:read` and `packages:delete` scopes.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `read:packages` and `delete:packages` scopes.
+         * If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         deletePackageVersionForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["packages"]["deletePackageVersionForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["deletePackageVersionForAuthenticatedUser"]["response"]>;
@@ -6050,9 +6465,9 @@ export declare type RestEndpointMethods = {
         /**
          * Deletes a specific package version in an organization. If the package is public and the package version has more than 5,000 downloads, you cannot delete the package version. In this scenario, contact GitHub support for further assistance.
          *
-         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `packages:read` and `packages:delete` scopes. In addition:
-         * - If `package_type` is not `container`, your token must also include the `repo` scope.
-         * - If `package_type` is `container`, you must also have admin permissions to the container you want to delete.
+         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `read:packages` and `delete:packages` scopes. In addition:
+         * - If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
+         * - If the `package_type` belongs to a GitHub Packages registry that supports granular permissions, you must have admin permissions to the package whose version you want to delete. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#granular-permissions-for-userorganization-scoped-packages)."
          */
         deletePackageVersionForOrg: {
             (params?: RestEndpointMethodTypes["packages"]["deletePackageVersionForOrg"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["deletePackageVersionForOrg"]["response"]>;
@@ -6064,9 +6479,9 @@ export declare type RestEndpointMethods = {
         /**
          * Deletes a specific package version for a user. If the package is public and the package version has more than 5,000 downloads, you cannot delete the package version. In this scenario, contact GitHub support for further assistance.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` and `packages:delete` scopes. In addition:
-         * - If `package_type` is not `container`, your token must also include the `repo` scope.
-         * - If `package_type` is `container`, you must also have admin permissions to the container you want to delete.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` and `delete:packages` scopes. In addition:
+         * - If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
+         * - If the `package_type` belongs to a GitHub Packages registry that supports granular permissions, you must have admin permissions to the package whose version you want to delete. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#granular-permissions-for-userorganization-scoped-packages)."
          */
         deletePackageVersionForUser: {
             (params?: RestEndpointMethodTypes["packages"]["deletePackageVersionForUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["deletePackageVersionForUser"]["response"]>;
@@ -6078,8 +6493,7 @@ export declare type RestEndpointMethods = {
         /**
          * Lists package versions for a package owned by an organization.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          * @deprecated octokit.rest.packages.getAllPackageVersionsForAPackageOwnedByAnOrg() has been renamed to octokit.rest.packages.getAllPackageVersionsForPackageOwnedByOrg() (2021-03-24)
          */
         getAllPackageVersionsForAPackageOwnedByAnOrg: {
@@ -6092,8 +6506,7 @@ export declare type RestEndpointMethods = {
         /**
          * Lists package versions for a package owned by the authenticated user.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          * @deprecated octokit.rest.packages.getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser() has been renamed to octokit.rest.packages.getAllPackageVersionsForPackageOwnedByAuthenticatedUser() (2021-03-24)
          */
         getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: {
@@ -6106,8 +6519,7 @@ export declare type RestEndpointMethods = {
         /**
          * Lists package versions for a package owned by the authenticated user.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         getAllPackageVersionsForPackageOwnedByAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["packages"]["getAllPackageVersionsForPackageOwnedByAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getAllPackageVersionsForPackageOwnedByAuthenticatedUser"]["response"]>;
@@ -6119,8 +6531,7 @@ export declare type RestEndpointMethods = {
         /**
          * Lists package versions for a package owned by an organization.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         getAllPackageVersionsForPackageOwnedByOrg: {
             (params?: RestEndpointMethodTypes["packages"]["getAllPackageVersionsForPackageOwnedByOrg"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getAllPackageVersionsForPackageOwnedByOrg"]["response"]>;
@@ -6132,8 +6543,7 @@ export declare type RestEndpointMethods = {
         /**
          * Lists package versions for a public package owned by a specified user.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         getAllPackageVersionsForPackageOwnedByUser: {
             (params?: RestEndpointMethodTypes["packages"]["getAllPackageVersionsForPackageOwnedByUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getAllPackageVersionsForPackageOwnedByUser"]["response"]>;
@@ -6145,8 +6555,7 @@ export declare type RestEndpointMethods = {
         /**
          * Gets a specific package for a package owned by the authenticated user.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         getPackageForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["packages"]["getPackageForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getPackageForAuthenticatedUser"]["response"]>;
@@ -6158,8 +6567,7 @@ export declare type RestEndpointMethods = {
         /**
          * Gets a specific package in an organization.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         getPackageForOrganization: {
             (params?: RestEndpointMethodTypes["packages"]["getPackageForOrganization"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getPackageForOrganization"]["response"]>;
@@ -6171,8 +6579,7 @@ export declare type RestEndpointMethods = {
         /**
          * Gets a specific package metadata for a public package owned by a user.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         getPackageForUser: {
             (params?: RestEndpointMethodTypes["packages"]["getPackageForUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getPackageForUser"]["response"]>;
@@ -6184,8 +6591,7 @@ export declare type RestEndpointMethods = {
         /**
          * Gets a specific package version for a package owned by the authenticated user.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         getPackageVersionForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["packages"]["getPackageVersionForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getPackageVersionForAuthenticatedUser"]["response"]>;
@@ -6197,8 +6603,7 @@ export declare type RestEndpointMethods = {
         /**
          * Gets a specific package version in an organization.
          *
-         * You must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * You must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         getPackageVersionForOrganization: {
             (params?: RestEndpointMethodTypes["packages"]["getPackageVersionForOrganization"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getPackageVersionForOrganization"]["response"]>;
@@ -6208,13 +6613,45 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Gets a specific package version for a public package owned by a specified user.
-         *
-         * At this time, to use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * Gets a specific package version for a public package owned by a specified user.
+         *
+         * At this time, to use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
+         */
+        getPackageVersionForUser: {
+            (params?: RestEndpointMethodTypes["packages"]["getPackageVersionForUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getPackageVersionForUser"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists all packages that are owned by the authenticated user within the user's namespace, and that encountered a conflict during a Docker migration.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope.
+         */
+        listDockerMigrationConflictingPackagesForAuthenticatedUser: {
+            (params?: RestEndpointMethodTypes["packages"]["listDockerMigrationConflictingPackagesForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["listDockerMigrationConflictingPackagesForAuthenticatedUser"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists all packages that are in a specific organization, are readable by the requesting user, and that encountered a conflict during a Docker migration.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope.
+         */
+        listDockerMigrationConflictingPackagesForOrganization: {
+            (params?: RestEndpointMethodTypes["packages"]["listDockerMigrationConflictingPackagesForOrganization"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["listDockerMigrationConflictingPackagesForOrganization"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists all packages that are in a specific user's namespace, that the requesting user has access to, and that encountered a conflict during Docker migration.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope.
          */
-        getPackageVersionForUser: {
-            (params?: RestEndpointMethodTypes["packages"]["getPackageVersionForUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["getPackageVersionForUser"]["response"]>;
+        listDockerMigrationConflictingPackagesForUser: {
+            (params?: RestEndpointMethodTypes["packages"]["listDockerMigrationConflictingPackagesForUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["listDockerMigrationConflictingPackagesForUser"]["response"]>;
             defaults: RequestInterface["defaults"];
             endpoint: EndpointInterface<{
                 url: string;
@@ -6223,8 +6660,7 @@ export declare type RestEndpointMethods = {
         /**
          * Lists packages owned by the authenticated user within the user's namespace.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         listPackagesForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["packages"]["listPackagesForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["listPackagesForAuthenticatedUser"]["response"]>;
@@ -6234,10 +6670,9 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Lists all packages in an organization readable by the user.
+         * Lists packages in an organization readable by the user.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         listPackagesForOrganization: {
             (params?: RestEndpointMethodTypes["packages"]["listPackagesForOrganization"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["listPackagesForOrganization"]["response"]>;
@@ -6249,8 +6684,7 @@ export declare type RestEndpointMethods = {
         /**
          * Lists all packages in a user's namespace for which the requesting user has access.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` scope.
-         * If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` scope. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         listPackagesForUser: {
             (params?: RestEndpointMethodTypes["packages"]["listPackagesForUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["listPackagesForUser"]["response"]>;
@@ -6266,7 +6700,7 @@ export declare type RestEndpointMethods = {
          *   - The package was deleted within the last 30 days.
          *   - The same package namespace and version is still available and not reused for a new package. If the same package namespace is not available, you will not be able to restore your package. In this scenario, to restore the deleted package, you must delete the new package that uses the deleted package's namespace first.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` and `packages:write` scopes. If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` and `write:packages` scopes. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         restorePackageForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["packages"]["restorePackageForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["restorePackageForAuthenticatedUser"]["response"]>;
@@ -6282,9 +6716,9 @@ export declare type RestEndpointMethods = {
          *   - The package was deleted within the last 30 days.
          *   - The same package namespace and version is still available and not reused for a new package. If the same package namespace is not available, you will not be able to restore your package. In this scenario, to restore the deleted package, you must delete the new package that uses the deleted package's namespace first.
          *
-         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `packages:read` and `packages:write` scopes. In addition:
-         * - If `package_type` is not `container`, your token must also include the `repo` scope.
-         * - If `package_type` is `container`, you must also have admin permissions to the container that you want to restore.
+         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `read:packages` and `write:packages` scopes. In addition:
+         * - If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
+         * - If the `package_type` belongs to a GitHub Packages registry that supports granular permissions, you must have admin permissions to the package you want to restore. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#granular-permissions-for-userorganization-scoped-packages)."
          */
         restorePackageForOrg: {
             (params?: RestEndpointMethodTypes["packages"]["restorePackageForOrg"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["restorePackageForOrg"]["response"]>;
@@ -6300,9 +6734,9 @@ export declare type RestEndpointMethods = {
          *   - The package was deleted within the last 30 days.
          *   - The same package namespace and version is still available and not reused for a new package. If the same package namespace is not available, you will not be able to restore your package. In this scenario, to restore the deleted package, you must delete the new package that uses the deleted package's namespace first.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` and `packages:write` scopes. In addition:
-         * - If `package_type` is not `container`, your token must also include the `repo` scope.
-         * - If `package_type` is `container`, you must also have admin permissions to the container that you want to restore.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` and `write:packages` scopes. In addition:
+         * - If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
+         * - If the `package_type` belongs to a GitHub Packages registry that supports granular permissions, you must have admin permissions to the package you want to restore. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#granular-permissions-for-userorganization-scoped-packages)."
          */
         restorePackageForUser: {
             (params?: RestEndpointMethodTypes["packages"]["restorePackageForUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["restorePackageForUser"]["response"]>;
@@ -6318,7 +6752,7 @@ export declare type RestEndpointMethods = {
          *   - The package was deleted within the last 30 days.
          *   - The same package namespace and version is still available and not reused for a new package. If the same package namespace is not available, you will not be able to restore your package. In this scenario, to restore the deleted package, you must delete the new package that uses the deleted package's namespace first.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` and `packages:write` scopes. If `package_type` is not `container`, your token must also include the `repo` scope.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` and `write:packages` scopes. If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of GitHub Packages registries that only support repository-scoped permissions, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
          */
         restorePackageVersionForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["packages"]["restorePackageVersionForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["restorePackageVersionForAuthenticatedUser"]["response"]>;
@@ -6334,9 +6768,9 @@ export declare type RestEndpointMethods = {
          *   - The package was deleted within the last 30 days.
          *   - The same package namespace and version is still available and not reused for a new package. If the same package namespace is not available, you will not be able to restore your package. In this scenario, to restore the deleted package, you must delete the new package that uses the deleted package's namespace first.
          *
-         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `packages:read` and `packages:write` scopes. In addition:
-         * - If `package_type` is not `container`, your token must also include the `repo` scope.
-         * - If `package_type` is `container`, you must also have admin permissions to the container that you want to restore.
+         * To use this endpoint, you must have admin permissions in the organization and authenticate using an access token with the `read:packages` and `write:packages` scopes. In addition:
+         * - If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
+         * - If the `package_type` belongs to a GitHub Packages registry that supports granular permissions, you must have admin permissions to the package whose version you want to restore. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#granular-permissions-for-userorganization-scoped-packages)."
          */
         restorePackageVersionForOrg: {
             (params?: RestEndpointMethodTypes["packages"]["restorePackageVersionForOrg"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["restorePackageVersionForOrg"]["response"]>;
@@ -6352,9 +6786,9 @@ export declare type RestEndpointMethods = {
          *   - The package was deleted within the last 30 days.
          *   - The same package namespace and version is still available and not reused for a new package. If the same package namespace is not available, you will not be able to restore your package. In this scenario, to restore the deleted package, you must delete the new package that uses the deleted package's namespace first.
          *
-         * To use this endpoint, you must authenticate using an access token with the `packages:read` and `packages:write` scopes. In addition:
-         * - If `package_type` is not `container`, your token must also include the `repo` scope.
-         * - If `package_type` is `container`, you must also have admin permissions to the container that you want to restore.
+         * To use this endpoint, you must authenticate using an access token with the `read:packages` and `write:packages` scopes. In addition:
+         * - If the `package_type` belongs to a GitHub Packages registry that only supports repository-scoped permissions, your token must also include the `repo` scope. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#permissions-for-repository-scoped-packages)."
+         * - If the `package_type` belongs to a GitHub Packages registry that supports granular permissions, you must have admin permissions to the package whose version you want to restore. For the list of these registries, see "[About permissions for GitHub Packages](https://docs.github.com/packages/learn-github-packages/about-permissions-for-github-packages#granular-permissions-for-userorganization-scoped-packages)."
          */
         restorePackageVersionForUser: {
             (params?: RestEndpointMethodTypes["packages"]["restorePackageVersionForUser"]["parameters"]): Promise<RestEndpointMethodTypes["packages"]["restorePackageVersionForUser"]["response"]>;
@@ -6578,6 +7012,9 @@ export declare type RestEndpointMethods = {
         };
     };
     pulls: {
+        /**
+         * Checks if a pull request has been merged into the base branch. The HTTP status of the response indicates whether or not the pull request has been merged; the response body is empty.
+         */
         checkIfMerged: {
             (params?: RestEndpointMethodTypes["pulls"]["checkIfMerged"]["parameters"]): Promise<RestEndpointMethodTypes["pulls"]["checkIfMerged"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -6590,7 +7027,7 @@ export declare type RestEndpointMethods = {
          *
          * To open or update a pull request in a public repository, you must have write access to the head or the source branch. For organization-owned repositories, you must be a member of the organization that owns the repository to open or update a pull request.
          *
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-rate-limits)" for details.
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-rate-limits)" for details.
          */
         create: {
             (params?: RestEndpointMethodTypes["pulls"]["create"]["parameters"]): Promise<RestEndpointMethodTypes["pulls"]["create"]["response"]>;
@@ -6602,7 +7039,7 @@ export declare type RestEndpointMethods = {
         /**
          * Creates a reply to a review comment for a pull request. For the `comment_id`, provide the ID of the review comment you are replying to. This must be the ID of a _top-level review comment_, not a reply to that comment. Replies to replies are not supported.
          *
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          */
         createReplyForReviewComment: {
             (params?: RestEndpointMethodTypes["pulls"]["createReplyForReviewComment"]["parameters"]): Promise<RestEndpointMethodTypes["pulls"]["createReplyForReviewComment"]["response"]>;
@@ -6612,11 +7049,11 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          *
          * Pull request reviews created in the `PENDING` state are not submitted and therefore do not include the `submitted_at` property in the response. To create a pending review for a pull request, leave the `event` parameter blank. For more information about submitting a `PENDING` review, see "[Submit a review for a pull request](https://docs.github.com/rest/pulls#submit-a-review-for-a-pull-request)."
          *
-         * **Note:** To comment on a specific line in a file, you need to first determine the _position_ of that line in the diff. The GitHub REST API v3 offers the `application/vnd.github.v3.diff` [media type](https://docs.github.com/rest/overview/media-types#commits-commit-comparison-and-pull-requests). To see a pull request diff, add this media type to the `Accept` header of a call to the [single pull request](https://docs.github.com/rest/reference/pulls#get-a-pull-request) endpoint.
+         * **Note:** To comment on a specific line in a file, you need to first determine the _position_ of that line in the diff. The GitHub REST API offers the `application/vnd.github.v3.diff` [media type](https://docs.github.com/rest/overview/media-types#commits-commit-comparison-and-pull-requests). To see a pull request diff, add this media type to the `Accept` header of a call to the [single pull request](https://docs.github.com/rest/reference/pulls#get-a-pull-request) endpoint.
          *
          * The `position` value equals the number of lines down from the first "@@" hunk header in the file you want to add a comment. The line just below the "@@" line is position 1, the next line is position 2, and so on. The position in the diff continues to increase through lines of whitespace and additional hunks until the beginning of a new file.
          */
@@ -6634,7 +7071,7 @@ export declare type RestEndpointMethods = {
          *
          * **Note:** The position value equals the number of lines down from the first "@@" hunk header in the file you want to add a comment. The line just below the "@@" line is position 1, the next line is position 2, and so on. The position in the diff continues to increase through lines of whitespace and additional hunks until the beginning of a new file.
          *
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          */
         createReviewComment: {
             (params?: RestEndpointMethodTypes["pulls"]["createReviewComment"]["parameters"]): Promise<RestEndpointMethodTypes["pulls"]["createReviewComment"]["response"]>;
@@ -6643,6 +7080,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Deletes a pull request review that has not been submitted. Submitted reviews cannot be deleted.
+         */
         deletePendingReview: {
             (params?: RestEndpointMethodTypes["pulls"]["deletePendingReview"]["parameters"]): Promise<RestEndpointMethodTypes["pulls"]["deletePendingReview"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -6694,6 +7134,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Retrieves a pull request review by its ID.
+         */
         getReview: {
             (params?: RestEndpointMethodTypes["pulls"]["getReview"]["parameters"]): Promise<RestEndpointMethodTypes["pulls"]["getReview"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -6792,6 +7235,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
+         * Merges a pull request into the base branch.
          * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          */
         merge: {
@@ -6801,6 +7245,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Removes review requests from a pull request for a given set of users and/or teams.
+         */
         removeRequestedReviewers: {
             (params?: RestEndpointMethodTypes["pulls"]["removeRequestedReviewers"]["parameters"]): Promise<RestEndpointMethodTypes["pulls"]["removeRequestedReviewers"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -7141,10 +7588,6 @@ export declare type RestEndpointMethods = {
          * Protected branches are available in public repositories with GitHub Free and GitHub Free for organizations, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
          *
          * Grants the specified apps push access for this branch. Only installed GitHub Apps with `write` access to the `contents` permission can be added as authorized actors on a protected branch.
-         *
-         * | Type    | Description                                                                                                                                                |
-         * | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-         * | `array` | The GitHub Apps that have push access to this branch. Use the app's `slug`. **Note**: The list of users, apps, and teams in total is limited to 100 items. |
          */
         addAppAccessRestrictions: {
             (params?: RestEndpointMethodTypes["repos"]["addAppAccessRestrictions"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["addAppAccessRestrictions"]["response"]>;
@@ -7156,7 +7599,7 @@ export declare type RestEndpointMethods = {
         /**
          * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          *
-         * Adding an outside collaborator may be restricted by enterprise administrators. For more information, see "[Enforcing repository management policies in your enterprise](https://docs.github.com/enterprise-cloud@latest/admin/policies/enforcing-policies-for-your-enterprise/enforcing-repository-management-policies-in-your-enterprise#enforcing-a-policy-for-inviting-outside-collaborators-to-repositories)."
+         * Adding an outside collaborator may be restricted by enterprise administrators. For more information, see "[Enforcing repository management policies in your enterprise](https://docs.github.com/admin/policies/enforcing-policies-for-your-enterprise/enforcing-repository-management-policies-in-your-enterprise#enforcing-a-policy-for-inviting-outside-collaborators-to-repositories)."
          *
          * For more information on permission levels, see "[Repository permission levels for an organization](https://docs.github.com/github/setting-up-and-managing-organizations-and-teams/repository-permission-levels-for-an-organization#permission-levels-for-repositories-owned-by-an-organization)". There are restrictions on which permissions can be granted to organization members when an organization base role is in place. In this case, the permission being given must be equal to or higher than the org base permission. Otherwise, the request will fail with:
          *
@@ -7197,10 +7640,6 @@ export declare type RestEndpointMethods = {
          * Protected branches are available in public repositories with GitHub Free and GitHub Free for organizations, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
          *
          * Grants the specified teams push access for this branch. You can also give push access to child teams.
-         *
-         * | Type    | Description                                                                                                                                |
-         * | ------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-         * | `array` | The teams that can have push access. Use the team's `slug`. **Note**: The list of users, apps, and teams in total is limited to 100 items. |
          */
         addTeamAccessRestrictions: {
             (params?: RestEndpointMethodTypes["repos"]["addTeamAccessRestrictions"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["addTeamAccessRestrictions"]["response"]>;
@@ -7242,7 +7681,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Shows whether dependency alerts are enabled or disabled for a repository. The authenticated user must have admin read access to the repository. For more information, see "[About security alerts for vulnerable dependencies](https://docs.github.com/en/articles/about-security-alerts-for-vulnerable-dependencies)".
+         * Shows whether dependency alerts are enabled or disabled for a repository. The authenticated user must have admin read access to the repository. For more information, see "[About security alerts for vulnerable dependencies](https://docs.github.com/articles/about-security-alerts-for-vulnerable-dependencies)".
          */
         checkVulnerabilityAlerts: {
             (params?: RestEndpointMethodTypes["repos"]["checkVulnerabilityAlerts"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["checkVulnerabilityAlerts"]["response"]>;
@@ -7315,21 +7754,26 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * The `basehead` param is comprised of two parts: `base` and `head`. Both must be branch names in `repo`. To compare branches across other repositories in the same network as `repo`, use the format `<USERNAME>:branch`.
+         * Compares two commits against one another. You can compare branches in the same repository, or you can compare branches that exist in different repositories within the same repository network, including fork branches. For more information about how to view a repository's network, see "[Understanding connections between repositories](https://docs.github.com/repositories/viewing-activity-and-data-for-your-repository/understanding-connections-between-repositories)."
          *
-         * The response from the API is equivalent to running the `git log base..head` command; however, commits are returned in chronological order. Pass the appropriate [media type](https://docs.github.com/rest/overview/media-types/#commits-commit-comparison-and-pull-requests) to fetch diff and patch formats.
+         * This endpoint is equivalent to running the `git log BASE..HEAD` command, but it returns commits in a different order. The `git log BASE..HEAD` command returns commits in reverse chronological order, whereas the API returns commits in chronological order. You can pass the appropriate [media type](https://docs.github.com/rest/overview/media-types/#commits-commit-comparison-and-pull-requests) to fetch diff and patch formats.
          *
-         * The response also includes details on the files that were changed between the two commits. This includes the status of the change (for example, if a file was added, removed, modified, or renamed), and details of the change itself. For example, files with a `renamed` status have a `previous_filename` field showing the previous filename of the file, and files with a `modified` status have a `patch` field showing the changes made to the file.
+         * The API response includes details about the files that were changed between the two commits. This includes the status of the change (if a file was added, removed, modified, or renamed), and details of the change itself. For example, files with a `renamed` status have a `previous_filename` field showing the previous filename of the file, and files with a `modified` status have a `patch` field showing the changes made to the file.
+         *
+         * When calling this endpoint without any paging parameter (`per_page` or `page`), the returned list is limited to 250 commits, and the last commit in the list is the most recent of the entire comparison.
          *
          * **Working with large comparisons**
          *
-         * To process a response with a large number of commits, you can use (`per_page` or `page`) to paginate the results. When using paging, the list of changed files is only returned with page 1, but includes all changed files for the entire comparison. For more information on working with pagination, see "[Traversing with pagination](/rest/guides/traversing-with-pagination)."
+         * To process a response with a large number of commits, use a query parameter (`per_page` or `page`) to paginate the results. When using pagination:
          *
-         * When calling this API without any paging parameters (`per_page` or `page`), the returned list is limited to 250 commits and the last commit in the list is the most recent of the entire comparison. When a paging parameter is specified, the first commit in the returned list of each page is the earliest.
+         * - The list of changed files is only shown on the first page of results, but it includes all changed files for the entire comparison.
+         * - The results are returned in chronological order, but the last commit in the returned list may not be the most recent one in the entire set if there are more pages of results.
+         *
+         * For more information on working with pagination, see "[Using pagination in the REST API](https://docs.github.com/rest/guides/using-pagination-in-the-rest-api)."
          *
          * **Signature verification object**
          *
-         * The response will include a `verification` object that describes the result of verifying the commit's signature. The following fields are included in the `verification` object:
+         * The response will include a `verification` object that describes the result of verifying the commit's signature. The `verification` object includes the following fields:
          *
          * | Name | Type | Description |
          * | ---- | ---- | ----------- |
@@ -7349,7 +7793,7 @@ export declare type RestEndpointMethods = {
          * | `unsigned` | The object does not include a signature. |
          * | `unknown_signature_type` | A non-PGP signature was found in the commit. |
          * | `no_user` | No user was associated with the `committer` email address in the commit. |
-         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on her/his account. |
+         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
          * | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
          * | `unknown_key` | The key that made the signature has not been registered with any user's account. |
          * | `malformed_signature` | There was an error parsing the signature. |
@@ -7376,7 +7820,7 @@ export declare type RestEndpointMethods = {
         /**
          * Create a comment for a commit using its `:commit_sha`.
          *
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          */
         createCommitComment: {
             (params?: RestEndpointMethodTypes["repos"]["createCommitComment"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["createCommitComment"]["response"]>;
@@ -7485,6 +7929,20 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Enable a custom deployment protection rule for an environment.
+         *
+         * You must authenticate using an access token with the `repo` scope to use this endpoint. Enabling a custom protection rule requires admin or owner permissions to the repository. GitHub Apps must have the `actions:write` permission to use this endpoint.
+         *
+         * For more information about the app that is providing this custom deployment rule, see the [documentation for the `GET /apps/{app_slug}` endpoint](https://docs.github.com/rest/apps/apps#get-an-app).
+         */
+        createDeploymentProtectionRule: {
+            (params?: RestEndpointMethodTypes["repos"]["createDeploymentProtectionRule"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["createDeploymentProtectionRule"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Users with `push` access can create deployment statuses for a given deployment.
          *
@@ -7537,6 +7995,8 @@ export declare type RestEndpointMethods = {
          * Create a fork for the authenticated user.
          *
          * **Note**: Forking a Repository happens asynchronously. You may have to wait a short period of time before you can access the git objects. If this takes longer than 5 minutes, be sure to contact [GitHub Support](https://support.github.com/contact?tags=dotcom-rest-api).
+         *
+         * **Note**: Although this endpoint works with GitHub Apps, the GitHub App must be installed on the destination account with access to all repositories and on the source account with access to the source repository.
          */
         createFork: {
             (params?: RestEndpointMethodTypes["repos"]["createFork"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["createFork"]["response"]>;
@@ -7590,6 +8050,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Create a repository ruleset for an organization.
+         */
+        createOrgRuleset: {
+            (params?: RestEndpointMethodTypes["repos"]["createOrgRuleset"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["createOrgRuleset"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Create a GitHub Pages deployment for a repository.
          *
@@ -7604,6 +8074,8 @@ export declare type RestEndpointMethods = {
         };
         /**
          * Configures a GitHub Pages site. For more information, see "[About GitHub Pages](/github/working-with-github-pages/about-github-pages)."
+         *
+         * To use this endpoint, you must be a repository administrator, maintainer, or have the 'manage GitHub Pages settings' permission. A token with the `repo` scope or Pages write permission is required. GitHub Apps must have the `administration:write` and `pages:write` permissions.
          */
         createPagesSite: {
             (params?: RestEndpointMethodTypes["repos"]["createPagesSite"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["createPagesSite"]["response"]>;
@@ -7615,7 +8087,7 @@ export declare type RestEndpointMethods = {
         /**
          * Users with push access to the repository can create a release.
          *
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          */
         createRelease: {
             (params?: RestEndpointMethodTypes["repos"]["createRelease"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["createRelease"]["response"]>;
@@ -7624,6 +8096,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Create a ruleset for a repository.
+         */
+        createRepoRuleset: {
+            (params?: RestEndpointMethodTypes["repos"]["createRepoRuleset"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["createRepoRuleset"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * This creates a tag protection state for a repository.
          * This endpoint is only available to repository administrators.
@@ -7786,7 +8268,7 @@ export declare type RestEndpointMethods = {
          * *   Create a new deployment that is active so that the system has a record of the current state, then delete the previously active deployment.
          * *   Mark the active deployment as inactive by adding any non-successful deployment status.
          *
-         * For more information, see "[Create a deployment](https://docs.github.com/rest/reference/repos/#create-a-deployment)" and "[Create a deployment status](https://docs.github.com/rest/reference/repos#create-a-deployment-status)."
+         * For more information, see "[Create a deployment](https://docs.github.com/rest/deployments/deployments/#create-a-deployment)" and "[Create a deployment status](https://docs.github.com/rest/deployments/deployment-statuses#create-a-deployment-status)."
          */
         deleteDeployment: {
             (params?: RestEndpointMethodTypes["repos"]["deleteDeployment"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["deleteDeployment"]["response"]>;
@@ -7832,6 +8314,21 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Delete a ruleset for an organization.
+         */
+        deleteOrgRuleset: {
+            (params?: RestEndpointMethodTypes["repos"]["deleteOrgRuleset"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["deleteOrgRuleset"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Deletes a GitHub Pages site. For more information, see "[About GitHub Pages](/github/working-with-github-pages/about-github-pages).
+         *
+         * To use this endpoint, you must be a repository administrator, maintainer, or have the 'manage GitHub Pages settings' permission. A token with the `repo` scope or Pages write permission is required. GitHub Apps must have the `administration:write` and `pages:write` permissions.
+         */
         deletePagesSite: {
             (params?: RestEndpointMethodTypes["repos"]["deletePagesSite"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["deletePagesSite"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -7866,6 +8363,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Delete a ruleset for a repository.
+         */
+        deleteRepoRuleset: {
+            (params?: RestEndpointMethodTypes["repos"]["deleteRepoRuleset"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["deleteRepoRuleset"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * This deletes a tag protection state for a repository.
          * This endpoint is only available to repository administrators.
@@ -7885,7 +8392,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Disables automated security fixes for a repository. The authenticated user must have admin access to the repository. For more information, see "[Configuring automated security fixes](https://docs.github.com/en/articles/configuring-automated-security-fixes)".
+         * Disables automated security fixes for a repository. The authenticated user must have admin access to the repository. For more information, see "[Configuring automated security fixes](https://docs.github.com/articles/configuring-automated-security-fixes)".
          */
         disableAutomatedSecurityFixes: {
             (params?: RestEndpointMethodTypes["repos"]["disableAutomatedSecurityFixes"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["disableAutomatedSecurityFixes"]["response"]>;
@@ -7894,6 +8401,21 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Disables a custom deployment protection rule for an environment.
+         *
+         * You must authenticate using an access token with the `repo` scope to use this endpoint. Removing a custom protection rule requires admin or owner permissions to the repository. GitHub Apps must have the `actions:write` permission to use this endpoint. For more information, see "[Get an app](https://docs.github.com/rest/apps/apps#get-an-app)".
+         */
+        disableDeploymentProtectionRule: {
+            (params?: RestEndpointMethodTypes["repos"]["disableDeploymentProtectionRule"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["disableDeploymentProtectionRule"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Disables Git LFS for a repository. Access tokens must have the `admin:enterprise` scope.
+         */
         disableLfsForRepo: {
             (params?: RestEndpointMethodTypes["repos"]["disableLfsForRepo"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["disableLfsForRepo"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -7902,7 +8424,9 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Disables dependency alerts and the dependency graph for a repository. The authenticated user must have admin access to the repository. For more information, see "[About security alerts for vulnerable dependencies](https://docs.github.com/en/articles/about-security-alerts-for-vulnerable-dependencies)".
+         * Disables dependency alerts and the dependency graph for a repository.
+         * The authenticated user must have admin access to the repository. For more information,
+         * see "[About security alerts for vulnerable dependencies](https://docs.github.com/articles/about-security-alerts-for-vulnerable-dependencies)".
          */
         disableVulnerabilityAlerts: {
             (params?: RestEndpointMethodTypes["repos"]["disableVulnerabilityAlerts"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["disableVulnerabilityAlerts"]["response"]>;
@@ -7913,7 +8437,7 @@ export declare type RestEndpointMethods = {
         };
         /**
          * Gets a redirect URL to download a zip archive for a repository. If you omit `:ref`, the repository’s default branch (usually
-         * `master`) will be used. Please make sure your HTTP framework is configured to follow redirects or you will need to use
+         * `main`) will be used. Please make sure your HTTP framework is configured to follow redirects or you will need to use
          * the `Location` header to make a second `GET` request.
          *
          * **Note**: For private repositories, these links are temporary and expire after five minutes. If the repository is empty, you will receive a 404 when you follow the redirect.
@@ -7928,7 +8452,7 @@ export declare type RestEndpointMethods = {
         };
         /**
          * Gets a redirect URL to download a tar archive for a repository. If you omit `:ref`, the repository’s default branch (usually
-         * `master`) will be used. Please make sure your HTTP framework is configured to follow redirects or you will need to use
+         * `main`) will be used. Please make sure your HTTP framework is configured to follow redirects or you will need to use
          * the `Location` header to make a second `GET` request.
          * **Note**: For private repositories, these links are temporary and expire after five minutes.
          */
@@ -7941,7 +8465,7 @@ export declare type RestEndpointMethods = {
         };
         /**
          * Gets a redirect URL to download a zip archive for a repository. If you omit `:ref`, the repository’s default branch (usually
-         * `master`) will be used. Please make sure your HTTP framework is configured to follow redirects or you will need to use
+         * `main`) will be used. Please make sure your HTTP framework is configured to follow redirects or you will need to use
          * the `Location` header to make a second `GET` request.
          *
          * **Note**: For private repositories, these links are temporary and expire after five minutes. If the repository is empty, you will receive a 404 when you follow the redirect.
@@ -7954,7 +8478,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Enables automated security fixes for a repository. The authenticated user must have admin access to the repository. For more information, see "[Configuring automated security fixes](https://docs.github.com/en/articles/configuring-automated-security-fixes)".
+         * Enables automated security fixes for a repository. The authenticated user must have admin access to the repository. For more information, see "[Configuring automated security fixes](https://docs.github.com/articles/configuring-automated-security-fixes)".
          */
         enableAutomatedSecurityFixes: {
             (params?: RestEndpointMethodTypes["repos"]["enableAutomatedSecurityFixes"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["enableAutomatedSecurityFixes"]["response"]>;
@@ -7963,6 +8487,9 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Enables Git LFS for a repository. Access tokens must have the `admin:enterprise` scope.
+         */
         enableLfsForRepo: {
             (params?: RestEndpointMethodTypes["repos"]["enableLfsForRepo"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["enableLfsForRepo"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -7971,7 +8498,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Enables dependency alerts and the dependency graph for a repository. The authenticated user must have admin access to the repository. For more information, see "[About security alerts for vulnerable dependencies](https://docs.github.com/en/articles/about-security-alerts-for-vulnerable-dependencies)".
+         * Enables dependency alerts and the dependency graph for a repository. The authenticated user must have admin access to the repository. For more information, see "[About security alerts for vulnerable dependencies](https://docs.github.com/articles/about-security-alerts-for-vulnerable-dependencies)".
          */
         enableVulnerabilityAlerts: {
             (params?: RestEndpointMethodTypes["repos"]["enableVulnerabilityAlerts"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["enableVulnerabilityAlerts"]["response"]>;
@@ -7992,6 +8519,8 @@ export declare type RestEndpointMethods = {
         };
         /**
          * The `parent` and `source` objects are present when the repository is a fork. `parent` is the repository this repository was forked from, `source` is the ultimate source for the network.
+         *
+         * **Note:** In order to see the `security_and_analysis` block for a repository you must have admin permissions for the repository or be an owner or security manager for the organization that owns the repository. For more information, see "[Managing security managers in your organization](https://docs.github.com/organizations/managing-peoples-access-to-your-organization-with-roles/managing-security-managers-in-your-organization)."
          */
         get: {
             (params?: RestEndpointMethodTypes["repos"]["get"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["get"]["response"]>;
@@ -8024,6 +8553,18 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets all custom deployment protection rules that are enabled for an environment. Anyone with read access to the repository can use this endpoint. If the repository is private and you want to use a personal access token (classic), you must use an access token with the `repo` scope. GitHub Apps and fine-grained personal access tokens must have the `actions:read` permission to use this endpoint. For more information about environments, see "[Using environments for deployment](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment)."
+         *
+         * For more information about the app that is providing this custom deployment rule, see the [documentation for the `GET /apps/{app_slug}` endpoint](https://docs.github.com/rest/apps/apps#get-an-app).
+         */
+        getAllDeploymentProtectionRules: {
+            (params?: RestEndpointMethodTypes["repos"]["getAllDeploymentProtectionRules"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getAllDeploymentProtectionRules"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Lists the environments for a repository.
          *
@@ -8094,6 +8635,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Returns all rules that apply to the specified branch.
+         */
+        getBranchRules: {
+            (params?: RestEndpointMethodTypes["repos"]["getBranchRules"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getBranchRules"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Get the total number of clones and breakdown per day or week for the last 14 days. Timestamps are aligned to UTC midnight of the beginning of the day or week. Week begins on Monday.
          */
@@ -8172,7 +8723,7 @@ export declare type RestEndpointMethods = {
          * | `unsigned` | The object does not include a signature. |
          * | `unknown_signature_type` | A non-PGP signature was found in the commit. |
          * | `no_user` | No user was associated with the `committer` email address in the commit. |
-         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on her/his account. |
+         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
          * | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
          * | `unknown_key` | The key that made the signature has not been registered with any user's account. |
          * | `malformed_signature` | There was an error parsing the signature. |
@@ -8218,7 +8769,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Returns all community profile metrics for a repository. The repository must be public, and cannot be a fork.
+         * Returns all community profile metrics for a repository. The repository cannot be a fork.
          *
          * The returned metrics include an overall health score, the repository description, the presence of documentation, the
          * detected code of conduct, the detected license, and the presence of ISSUE\_TEMPLATE, PULL\_REQUEST\_TEMPLATE,
@@ -8300,6 +8851,18 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets an enabled custom deployment protection rule for an environment. Anyone with read access to the repository can use this endpoint. If the repository is private and you want to use a personal access token (classic), you must use an access token with the `repo` scope. GitHub Apps and fine-grained personal access tokens must have the `actions:read` permission to use this endpoint. For more information about environments, see "[Using environments for deployment](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment)."
+         *
+         * For more information about the app that is providing this custom deployment rule, see [`GET /apps/{app_slug}`](https://docs.github.com/rest/apps/apps#get-an-app).
+         */
+        getCustomDeploymentProtectionRule: {
+            (params?: RestEndpointMethodTypes["repos"]["getCustomDeploymentProtectionRule"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getCustomDeploymentProtectionRule"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         getDeployKey: {
             (params?: RestEndpointMethodTypes["repos"]["getDeployKey"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getDeployKey"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -8350,6 +8913,11 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets information about the single most recent build of a GitHub Pages site.
+         *
+         * A token with the `repo` scope is required. GitHub Apps must have the `pages:read` permission.
+         */
         getLatestPagesBuild: {
             (params?: RestEndpointMethodTypes["repos"]["getLatestPagesBuild"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getLatestPagesBuild"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -8369,6 +8937,31 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Get a repository ruleset for an organization.
+         */
+        getOrgRuleset: {
+            (params?: RestEndpointMethodTypes["repos"]["getOrgRuleset"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getOrgRuleset"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Get all the repository rulesets for an organization.
+         */
+        getOrgRulesets: {
+            (params?: RestEndpointMethodTypes["repos"]["getOrgRulesets"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getOrgRulesets"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Gets information about a GitHub Pages site.
+         *
+         * A token with the `repo` scope is required. GitHub Apps must have the `pages:read` permission.
+         */
         getPages: {
             (params?: RestEndpointMethodTypes["repos"]["getPages"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getPages"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -8376,6 +8969,11 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets information about a GitHub Pages build.
+         *
+         * A token with the `repo` scope is required. GitHub Apps must have the `pages:read` permission.
+         */
         getPagesBuild: {
             (params?: RestEndpointMethodTypes["repos"]["getPagesBuild"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getPagesBuild"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -8388,7 +8986,7 @@ export declare type RestEndpointMethods = {
          *
          * The first request to this endpoint returns a `202 Accepted` status and starts an asynchronous background task to get the results for the domain. After the background task completes, subsequent requests to this endpoint return a `200 OK` status with the health check results in the response.
          *
-         * Users must have admin or owner permissions. GitHub Apps must have the `pages:write` and `administration:write` permission to use this endpoint.
+         * To use this endpoint, you must be a repository administrator, maintainer, or have the 'manage GitHub Pages settings' permission. A token with the `repo` scope or Pages write permission is required. GitHub Apps must have the `administrative:write` and `pages:write` permissions.
          */
         getPagesHealthCheck: {
             (params?: RestEndpointMethodTypes["repos"]["getPagesHealthCheck"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getPagesHealthCheck"]["response"]>;
@@ -8489,6 +9087,26 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Get a ruleset for a repository.
+         */
+        getRepoRuleset: {
+            (params?: RestEndpointMethodTypes["repos"]["getRepoRuleset"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getRepoRuleset"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Get all the rulesets for a repository.
+         */
+        getRepoRulesets: {
+            (params?: RestEndpointMethodTypes["repos"]["getRepoRulesets"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["getRepoRulesets"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Protected branches are available in public repositories with GitHub Free and GitHub Free for organizations, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
          */
@@ -8690,7 +9308,7 @@ export declare type RestEndpointMethods = {
          * | `unsigned` | The object does not include a signature. |
          * | `unknown_signature_type` | A non-PGP signature was found in the commit. |
          * | `no_user` | No user was associated with the `committer` email address in the commit. |
-         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on her/his account. |
+         * | `unverified_email` | The `committer` email address in the commit was associated with a user, but the email address is not verified on their account. |
          * | `bad_email` | The `committer` email address in the commit is not included in the identities of the PGP key that made the signature. |
          * | `unknown_key` | The key that made the signature has not been registered with any user's account. |
          * | `malformed_signature` | There was an error parsing the signature. |
@@ -8705,7 +9323,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Lists contributors to the specified repository and sorts them by the number of commits per contributor in descending order. This endpoint may return information that is a few hours old because the GitHub REST API v3 caches contributor data to improve performance.
+         * Lists contributors to the specified repository and sorts them by the number of commits per contributor in descending order. This endpoint may return information that is a few hours old because the GitHub REST API caches contributor data to improve performance.
          *
          * GitHub identifies contributors by author email address. This endpoint groups contribution counts by GitHub user, which includes all associated email addresses. To improve performance, only the first 500 author email addresses in the repository link to GitHub users. The rest will appear as anonymous contributors without associated GitHub user information.
          */
@@ -8716,6 +9334,20 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Gets all custom deployment protection rule integrations that are available for an environment. Anyone with read access to the repository can use this endpoint. If the repository is private and you want to use a personal access token (classic), you must use an access token with the `repo` scope. GitHub Apps and fine-grained personal access tokens must have the `actions:read` permission to use this endpoint.
+         *
+         * For more information about environments, see "[Using environments for deployment](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment)."
+         *
+         * For more information about the app that is providing this custom deployment rule, see "[GET an app](https://docs.github.com/rest/apps/apps#get-an-app)".
+         */
+        listCustomDeploymentRuleIntegrations: {
+            (params?: RestEndpointMethodTypes["repos"]["listCustomDeploymentRuleIntegrations"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["listCustomDeploymentRuleIntegrations"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         listDeployKeys: {
             (params?: RestEndpointMethodTypes["repos"]["listDeployKeys"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["listDeployKeys"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -8769,6 +9401,8 @@ export declare type RestEndpointMethods = {
         };
         /**
          * Lists repositories for the specified organization.
+         *
+         * **Note:** In order to see the `security_and_analysis` block for a repository you must have admin permissions for the repository or be an owner or security manager for the organization that owns the repository. For more information, see "[Managing security managers in your organization](https://docs.github.com/organizations/managing-peoples-access-to-your-organization-with-roles/managing-security-managers-in-your-organization)."
          */
         listForOrg: {
             (params?: RestEndpointMethodTypes["repos"]["listForOrg"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["listForOrg"]["response"]>;
@@ -8824,6 +9458,11 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Lists builts of a GitHub Pages site.
+         *
+         * A token with the `repo` scope is required. GitHub Apps must have the `pages:read` permission.
+         */
         listPagesBuilds: {
             (params?: RestEndpointMethodTypes["repos"]["listPagesBuilds"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["listPagesBuilds"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -8836,7 +9475,7 @@ export declare type RestEndpointMethods = {
          *
          * Note:
          * - For GitHub Enterprise Server, this endpoint will only list repositories available to all users on the enterprise.
-         * - Pagination is powered exclusively by the `since` parameter. Use the [Link header](https://docs.github.com/rest/overview/resources-in-the-rest-api#link-header) to get the URL for the next page of repositories.
+         * - Pagination is powered exclusively by the `since` parameter. Use the [Link header](https://docs.github.com/rest/guides/using-pagination-in-the-rest-api#using-link-headers) to get the URL for the next page of repositories.
          */
         listPublic: {
             (params?: RestEndpointMethodTypes["repos"]["listPublic"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["listPublic"]["response"]>;
@@ -8846,7 +9485,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Lists the merged pull request that introduced the commit to the repository. If the commit is not present in the default branch, additionally returns open pull requests associated with the commit. The results may include open and closed pull requests.
+         * Lists the merged pull request that introduced the commit to the repository. If the commit is not present in the default branch, will only return open pull requests associated with the commit.
          */
         listPullRequestsAssociatedWithCommit: {
             (params?: RestEndpointMethodTypes["repos"]["listPullRequestsAssociatedWithCommit"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["listPullRequestsAssociatedWithCommit"]["response"]>;
@@ -8961,10 +9600,6 @@ export declare type RestEndpointMethods = {
          * Protected branches are available in public repositories with GitHub Free and GitHub Free for organizations, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
          *
          * Removes the ability of an app to push to this branch. Only installed GitHub Apps with `write` access to the `contents` permission can be added as authorized actors on a protected branch.
-         *
-         * | Type    | Description                                                                                                                                                |
-         * | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-         * | `array` | The GitHub Apps that have push access to this branch. Use the app's `slug`. **Note**: The list of users, apps, and teams in total is limited to 100 items. |
          */
         removeAppAccessRestrictions: {
             (params?: RestEndpointMethodTypes["repos"]["removeAppAccessRestrictions"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["removeAppAccessRestrictions"]["response"]>;
@@ -9004,10 +9639,6 @@ export declare type RestEndpointMethods = {
          * Protected branches are available in public repositories with GitHub Free and GitHub Free for organizations, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
          *
          * Removes the ability of a team to push to this branch. You can also remove push access for child teams.
-         *
-         * | Type    | Description                                                                                                                                         |
-         * | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
-         * | `array` | Teams that should no longer have push access. Use the team's `slug`. **Note**: The list of users, apps, and teams in total is limited to 100 items. |
          */
         removeTeamAccessRestrictions: {
             (params?: RestEndpointMethodTypes["repos"]["removeTeamAccessRestrictions"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["removeTeamAccessRestrictions"]["response"]>;
@@ -9091,10 +9722,6 @@ export declare type RestEndpointMethods = {
          * Protected branches are available in public repositories with GitHub Free and GitHub Free for organizations, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
          *
          * Replaces the list of apps that have push access to this branch. This removes all apps that previously had push access and grants push access to the new list of apps. Only installed GitHub Apps with `write` access to the `contents` permission can be added as authorized actors on a protected branch.
-         *
-         * | Type    | Description                                                                                                                                                |
-         * | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-         * | `array` | The GitHub Apps that have push access to this branch. Use the app's `slug`. **Note**: The list of users, apps, and teams in total is limited to 100 items. |
          */
         setAppAccessRestrictions: {
             (params?: RestEndpointMethodTypes["repos"]["setAppAccessRestrictions"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["setAppAccessRestrictions"]["response"]>;
@@ -9117,10 +9744,6 @@ export declare type RestEndpointMethods = {
          * Protected branches are available in public repositories with GitHub Free and GitHub Free for organizations, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
          *
          * Replaces the list of teams that have push access to this branch. This removes all teams that previously had push access and grants push access to the new list of teams. Team restrictions include child teams.
-         *
-         * | Type    | Description                                                                                                                                |
-         * | ------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-         * | `array` | The teams that can have push access. Use the team's `slug`. **Note**: The list of users, apps, and teams in total is limited to 100 items. |
          */
         setTeamAccessRestrictions: {
             (params?: RestEndpointMethodTypes["repos"]["setTeamAccessRestrictions"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["setTeamAccessRestrictions"]["response"]>;
@@ -9214,6 +9837,8 @@ export declare type RestEndpointMethods = {
         };
         /**
          * Updates information for a GitHub Pages site. For more information, see "[About GitHub Pages](/github/working-with-github-pages/about-github-pages).
+         *
+         * To use this endpoint, you must be a repository administrator, maintainer, or have the 'manage GitHub Pages settings' permission. A token with the `repo` scope or Pages write permission is required. GitHub Apps must have the `administration:write` and `pages:write` permissions.
          */
         updateInformationAboutPagesSite: {
             (params?: RestEndpointMethodTypes["repos"]["updateInformationAboutPagesSite"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["updateInformationAboutPagesSite"]["response"]>;
@@ -9229,6 +9854,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Update a ruleset for an organization.
+         */
+        updateOrgRuleset: {
+            (params?: RestEndpointMethodTypes["repos"]["updateOrgRuleset"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["updateOrgRuleset"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Protected branches are available in public repositories with GitHub Free and GitHub Free for organizations, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
          *
@@ -9263,6 +9898,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Update a ruleset for a repository.
+         */
+        updateRepoRuleset: {
+            (params?: RestEndpointMethodTypes["repos"]["updateRepoRuleset"]["parameters"]): Promise<RestEndpointMethodTypes["repos"]["updateRepoRuleset"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Protected branches are available in public repositories with GitHub Free and GitHub Free for organizations, and in public and private repositories with GitHub Pro, GitHub Team, GitHub Enterprise Cloud, and GitHub Enterprise Server. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
          *
@@ -9312,7 +9957,7 @@ export declare type RestEndpointMethods = {
         };
         /**
          * This endpoint makes use of [a Hypermedia relation](https://docs.github.com/rest/overview/resources-in-the-rest-api#hypermedia) to determine which URL to access. The endpoint you call to upload release assets is specific to your release. Use the `upload_url` returned in
-         * the response of the [Create a release endpoint](https://docs.github.com/rest/reference/repos#create-a-release) to upload a release asset.
+         * the response of the [Create a release endpoint](https://docs.github.com/rest/releases/releases#create-a-release) to upload a release asset.
          *
          * You need to use an HTTP client which supports [SNI](http://en.wikipedia.org/wiki/Server_Name_Indication) to make calls to this endpoint.
          *
@@ -9328,6 +9973,7 @@ export declare type RestEndpointMethods = {
          * **Notes:**
          * *   GitHub renames asset filenames that have special characters, non-alphanumeric characters, and leading or trailing periods. The "[List assets for a release](https://docs.github.com/rest/reference/repos#list-assets-for-a-release)"
          * endpoint lists the renamed filenames. For more information and help, contact [GitHub Support](https://support.github.com/contact?tags=dotcom-rest-api).
+         * *   To find the `release_id` query the [`GET /repos/{owner}/{repo}/releases/latest` endpoint](https://docs.github.com/rest/releases/releases#get-the-latest-release).
          * *   If you upload an asset with the same filename as another uploaded asset, you'll receive an error and must delete the old file before you can re-upload the new asset.
          */
         uploadReleaseAsset: {
@@ -9358,6 +10004,8 @@ export declare type RestEndpointMethods = {
          * *   Only files smaller than 384 KB are searchable.
          * *   You must always include at least one search term when searching source code. For example, searching for [`language:go`](https://github.com/search?utf8=%E2%9C%93&q=language%3Ago&type=Code) is not valid, while [`amazing
          * language:go`](https://github.com/search?utf8=%E2%9C%93&q=amazing+language%3Ago&type=Code) is.
+         *
+         * This endpoint requires you to authenticate and limits you to 10 requests per minute.
          */
         code: {
             (params?: RestEndpointMethodTypes["search"]["code"]["parameters"]): Promise<RestEndpointMethodTypes["search"]["code"]["response"]>;
@@ -9367,7 +10015,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Find commits via various criteria on the default branch (usually `master`). This method returns up to 100 results [per page](https://docs.github.com/rest/overview/resources-in-the-rest-api#pagination).
+         * Find commits via various criteria on the default branch (usually `main`). This method returns up to 100 results [per page](https://docs.github.com/rest/overview/resources-in-the-rest-api#pagination).
          *
          * When searching for commits, you can get text match metadata for the **message** field when you provide the `text-match` media type. For more details about how to receive highlighted search results, see [Text match
          * metadata](https://docs.github.com/rest/reference/search#text-match-metadata).
@@ -9560,12 +10208,82 @@ export declare type RestEndpointMethods = {
             }>;
         };
     };
-    teams: {
+    securityAdvisories: {
         /**
-         * Team synchronization is available for organizations using GitHub Enterprise Cloud. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
+         * Report a security vulnerability to the maintainers of the repository.
+         * See "[Privately reporting a security vulnerability](https://docs.github.com/code-security/security-advisories/guidance-on-reporting-and-writing/privately-reporting-a-security-vulnerability)" for more information about private vulnerability reporting.
+         */
+        createPrivateVulnerabilityReport: {
+            (params?: RestEndpointMethodTypes["securityAdvisories"]["createPrivateVulnerabilityReport"]["parameters"]): Promise<RestEndpointMethodTypes["securityAdvisories"]["createPrivateVulnerabilityReport"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Creates a new repository security advisory.
+         * You must authenticate using an access token with the `repo` scope or `repository_advisories:write` permission to use this endpoint.
+         *
+         * In order to create a draft repository security advisory, you must be a security manager or administrator of that repository.
+         */
+        createRepositoryAdvisory: {
+            (params?: RestEndpointMethodTypes["securityAdvisories"]["createRepositoryAdvisory"]["parameters"]): Promise<RestEndpointMethodTypes["securityAdvisories"]["createRepositoryAdvisory"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Get a repository security advisory using its GitHub Security Advisory (GHSA) identifier.
+         * You can access any published security advisory on a public repository.
+         * You must authenticate using an access token with the `repo` scope or `repository_advisories:read` permission
+         * in order to get a published security advisory in a private repository, or any unpublished security advisory that you have access to.
+         *
+         * You can access an unpublished security advisory from a repository if you are a security manager or administrator of that repository, or if you are a
+         * collaborator on the security advisory.
+         */
+        getRepositoryAdvisory: {
+            (params?: RestEndpointMethodTypes["securityAdvisories"]["getRepositoryAdvisory"]["parameters"]): Promise<RestEndpointMethodTypes["securityAdvisories"]["getRepositoryAdvisory"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists security advisories in a repository.
+         * You must authenticate using an access token with the `repo` scope or `repository_advisories:read` permission
+         * in order to get published security advisories in a private repository, or any unpublished security advisories that you have access to.
+         *
+         * You can access unpublished security advisories from a repository if you are a security manager or administrator of that repository, or if you are a collaborator on any security advisory.
+         */
+        listRepositoryAdvisories: {
+            (params?: RestEndpointMethodTypes["securityAdvisories"]["listRepositoryAdvisories"]["parameters"]): Promise<RestEndpointMethodTypes["securityAdvisories"]["listRepositoryAdvisories"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Update a repository security advisory using its GitHub Security Advisory (GHSA) identifier.
+         * You must authenticate using an access token with the `repo` scope or `repository_advisories:write` permission to use this endpoint.
          *
+         * In order to update any security advisory, you must be a security manager or administrator of that repository,
+         * or a collaborator on the repository security advisory.
+         */
+        updateRepositoryAdvisory: {
+            (params?: RestEndpointMethodTypes["securityAdvisories"]["updateRepositoryAdvisory"]["parameters"]): Promise<RestEndpointMethodTypes["securityAdvisories"]["updateRepositoryAdvisory"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+    };
+    teams: {
+        /**
          * Adds an organization member to a team. An authenticated organization owner or team maintainer can add organization members to a team.
          *
+         * Team synchronization is available for organizations using GitHub Enterprise Cloud. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
+         *
          * **Note:** When you have team synchronization set up for a team with your organization's identity provider (IdP), you will see an error if you attempt to use the API for making changes to the team's membership. If you have access to manage group membership in your IdP, you can manage GitHub team membership through your identity provider, which automatically adds and removes team members in an organization. For more information, see "[Synchronizing teams between your identity provider and GitHub](https://docs.github.com/articles/synchronizing-teams-between-your-identity-provider-and-github/)."
          *
          * An organization owner can add someone who is not part of the team's organization to a team. When an organization owner adds someone to a team who is not an organization member, this endpoint will send an invitation to the person via email. This newly-created membership will be in the "pending" state until the person accepts the invitation, at which point the membership will transition to the "active" state and the user will be added as a member of the team.
@@ -9598,7 +10316,7 @@ export declare type RestEndpointMethods = {
          *
          * **Note:** You can also specify a team by `org_id` and `team_id` using the route `PUT /organizations/{org_id}/team/{team_id}/repos/{owner}/{repo}`.
          *
-         * For more information about the permission levels, see "[Repository permission levels for an organization](https://docs.github.com/en/github/setting-up-and-managing-organizations-and-teams/repository-permission-levels-for-an-organization#permission-levels-for-repositories-owned-by-an-organization)".
+         * For more information about the permission levels, see "[Repository permission levels for an organization](https://docs.github.com/github/setting-up-and-managing-organizations-and-teams/repository-permission-levels-for-an-organization#permission-levels-for-repositories-owned-by-an-organization)".
          */
         addOrUpdateRepoPermissionsInOrg: {
             (params?: RestEndpointMethodTypes["teams"]["addOrUpdateRepoPermissionsInOrg"]["parameters"]): Promise<RestEndpointMethodTypes["teams"]["addOrUpdateRepoPermissionsInOrg"]["response"]>;
@@ -9636,9 +10354,9 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * To create a team, the authenticated user must be a member or owner of `{org}`. By default, organization members can create teams. Organization owners can limit team creation to organization owners. For more information, see "[Setting team creation permissions](https://docs.github.com/en/articles/setting-team-creation-permissions-in-your-organization)."
+         * To create a team, the authenticated user must be a member or owner of `{org}`. By default, organization members can create teams. Organization owners can limit team creation to organization owners. For more information, see "[Setting team creation permissions](https://docs.github.com/articles/setting-team-creation-permissions-in-your-organization)."
          *
-         * When you create a new team, you automatically become a team maintainer without explicitly adding yourself to the optional array of `maintainers`. For more information, see "[About teams](https://docs.github.com/en/github/setting-up-and-managing-organizations-and-teams/about-teams)".
+         * When you create a new team, you automatically become a team maintainer without explicitly adding yourself to the optional array of `maintainers`. For more information, see "[About teams](https://docs.github.com/github/setting-up-and-managing-organizations-and-teams/about-teams)".
          */
         create: {
             (params?: RestEndpointMethodTypes["teams"]["create"]["parameters"]): Promise<RestEndpointMethodTypes["teams"]["create"]["response"]>;
@@ -9650,7 +10368,7 @@ export declare type RestEndpointMethods = {
         /**
          * Creates a new comment on a team discussion. OAuth access tokens require the `write:discussion` [scope](https://docs.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/).
          *
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          *
          * **Note:** You can also specify a team by `org_id` and `team_id` using the route `POST /organizations/{org_id}/team/{team_id}/discussions/{discussion_number}/comments`.
          */
@@ -9664,7 +10382,7 @@ export declare type RestEndpointMethods = {
         /**
          * Creates a new discussion post on a team's page. OAuth access tokens require the `write:discussion` [scope](https://docs.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/).
          *
-         * This endpoint triggers [notifications](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
+         * This endpoint triggers [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). Creating content too quickly using this endpoint may result in secondary rate limiting. See "[Secondary rate limits](https://docs.github.com/rest/overview/resources-in-the-rest-api#secondary-rate-limits)" and "[Dealing with secondary rate limits](https://docs.github.com/rest/guides/best-practices-for-integrators#dealing-with-secondary-rate-limits)" for details.
          *
          * **Note:** You can also specify a team by `org_id` and `team_id` using the route `POST /organizations/{org_id}/team/{team_id}/discussions`.
          */
@@ -9714,7 +10432,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Gets a team using the team's `slug`. GitHub generates the `slug` from the team `name`.
+         * Gets a team using the team's `slug`. To create the `slug`, GitHub replaces special characters in the `name` string, changes all words to lowercase, and replaces spaces with a `-` separator. For example, `"My TEam Näme"` would become `my-team-name`.
          *
          * **Note:** You can also specify a team by `org_id` and `team_id` using the route `GET /organizations/{org_id}/team/{team_id}`.
          */
@@ -9815,7 +10533,7 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * List all of the teams across all of the organizations to which the authenticated user belongs. This method requires `user`, `repo`, or `read:org` [scope](https://docs.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/) when authenticating via [OAuth](https://docs.github.com/apps/building-oauth-apps/).
+         * List all of the teams across all of the organizations to which the authenticated user belongs. This method requires `user`, `repo`, or `read:org` [scope](https://docs.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/) when authenticating via [OAuth](https://docs.github.com/apps/building-oauth-apps/). When using a fine-grained personal access token, the resource owner of the token [must be a single organization](https://docs.github.com/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token#fine-grained-personal-access-tokens), and have at least read-only member organization permissions. The response payload only contains the teams from a single organization when using a fine-grained personal access token.
          */
         listForAuthenticatedUser: {
             (params?: RestEndpointMethodTypes["teams"]["listForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["teams"]["listForAuthenticatedUser"]["response"]>;
@@ -9873,10 +10591,10 @@ export declare type RestEndpointMethods = {
             }>;
         };
         /**
-         * Team synchronization is available for organizations using GitHub Enterprise Cloud. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
-         *
          * To remove a membership between a user and a team, the authenticated user must have 'admin' permissions to the team or be an owner of the organization that the team is associated with. Removing team membership does not delete the user, it just removes their membership from the team.
          *
+         * Team synchronization is available for organizations using GitHub Enterprise Cloud. For more information, see [GitHub's products](https://docs.github.com/github/getting-started-with-github/githubs-products) in the GitHub Help documentation.
+         *
          * **Note:** When you have team synchronization set up for a team with your organization's identity provider (IdP), you will see an error if you attempt to use the API for making changes to the team's membership. If you have access to manage group membership in your IdP, you can manage GitHub team membership through your identity provider, which automatically adds and removes team members in an organization. For more information, see "[Synchronizing teams between your identity provider and GitHub](https://docs.github.com/articles/synchronizing-teams-between-your-identity-provider-and-github/)."
          *
          * **Note:** You can also specify a team by `org_id` and `team_id` using the route `DELETE /organizations/{org_id}/team/{team_id}/memberships/{username}`.
@@ -9971,6 +10689,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Add one or more social accounts to the authenticated user's profile. This endpoint is accessible with the `user` scope.
+         */
+        addSocialAccountForAuthenticatedUser: {
+            (params?: RestEndpointMethodTypes["users"]["addSocialAccountForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["users"]["addSocialAccountForAuthenticatedUser"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         block: {
             (params?: RestEndpointMethodTypes["users"]["block"]["parameters"]): Promise<RestEndpointMethodTypes["users"]["block"]["response"]>;
             defaults: RequestInterface["defaults"];
@@ -10114,6 +10842,16 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Deletes one or more social accounts from the authenticated user's profile. This endpoint is accessible with the `user` scope.
+         */
+        deleteSocialAccountForAuthenticatedUser: {
+            (params?: RestEndpointMethodTypes["users"]["deleteSocialAccountForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["users"]["deleteSocialAccountForAuthenticatedUser"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Deletes an SSH signing key from the authenticated user's GitHub account. You must authenticate with Basic Authentication, or you must authenticate with OAuth with at least `admin:ssh_signing_key` scope. For more information, see "[Understanding scopes for OAuth apps](https://docs.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/)."
          */
@@ -10236,7 +10974,7 @@ export declare type RestEndpointMethods = {
         /**
          * Lists all users, in the order that they signed up on GitHub. This list includes personal user accounts and organization accounts.
          *
-         * Note: Pagination is powered exclusively by the `since` parameter. Use the [Link header](https://docs.github.com/rest/overview/resources-in-the-rest-api#link-header) to get the URL for the next page of users.
+         * Note: Pagination is powered exclusively by the `since` parameter. Use the [Link header](https://docs.github.com/rest/guides/using-pagination-in-the-rest-api#using-link-headers) to get the URL for the next page of users.
          */
         list: {
             (params?: RestEndpointMethodTypes["users"]["list"]["parameters"]): Promise<RestEndpointMethodTypes["users"]["list"]["response"]>;
@@ -10421,6 +11159,26 @@ export declare type RestEndpointMethods = {
                 url: string;
             }>;
         };
+        /**
+         * Lists all of your social accounts.
+         */
+        listSocialAccountsForAuthenticatedUser: {
+            (params?: RestEndpointMethodTypes["users"]["listSocialAccountsForAuthenticatedUser"]["parameters"]): Promise<RestEndpointMethodTypes["users"]["listSocialAccountsForAuthenticatedUser"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
+        /**
+         * Lists social media accounts for a user. This endpoint is accessible by anyone.
+         */
+        listSocialAccountsForUser: {
+            (params?: RestEndpointMethodTypes["users"]["listSocialAccountsForUser"]["parameters"]): Promise<RestEndpointMethodTypes["users"]["listSocialAccountsForUser"]["response"]>;
+            defaults: RequestInterface["defaults"];
+            endpoint: EndpointInterface<{
+                url: string;
+            }>;
+        };
         /**
          * Lists the SSH signing keys for the authenticated user's GitHub account. You must authenticate with Basic Authentication, or you must authenticate with OAuth with at least `read:ssh_signing_key` scope. For more information, see "[Understanding scopes for OAuth apps](https://docs.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/)."
          */