@meetkai/mka1 0.54.52 → 0.54.53

package/src/react-query/sandboxGithubRefreshRepositories.ts

@@ -0,0 +1,110 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { SDKCore } from "../core.js";
+import { sandboxGithubRefreshRepositories } from "../funcs/sandboxGithubRefreshRepositories.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useSDKContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type SandboxGithubRefreshRepositoriesMutationVariables = {
+  request: operations.RefreshGitHubRepositoriesRequest;
+  options?: RequestOptions;
+};
+
+export type SandboxGithubRefreshRepositoriesMutationData =
+  components.RepositoryList;
+
+export type SandboxGithubRefreshRepositoriesMutationError =
+  | SDKError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+/**
+ * Refresh GitHub Repositories
+ *
+ * @remarks
+ * Re-read the repositories the caller's GitHub connection can reach, save them as the connection's repository list, and return it.
+ */
+export function useSandboxGithubRefreshRepositoriesMutation(
+  options?: MutationHookOptions<
+    SandboxGithubRefreshRepositoriesMutationData,
+    SandboxGithubRefreshRepositoriesMutationError,
+    SandboxGithubRefreshRepositoriesMutationVariables
+  >,
+): UseMutationResult<
+  SandboxGithubRefreshRepositoriesMutationData,
+  SandboxGithubRefreshRepositoriesMutationError,
+  SandboxGithubRefreshRepositoriesMutationVariables
+> {
+  const client = useSDKContext();
+  return useMutation({
+    ...buildSandboxGithubRefreshRepositoriesMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeySandboxGithubRefreshRepositories(): MutationKey {
+  return ["@meetkai/mka1", "github", "refreshRepositories"];
+}
+
+export function buildSandboxGithubRefreshRepositoriesMutation(
+  client$: SDKCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: SandboxGithubRefreshRepositoriesMutationVariables,
+  ) => Promise<SandboxGithubRefreshRepositoriesMutationData>;
+} {
+  return {
+    mutationKey: mutationKeySandboxGithubRefreshRepositories(),
+    mutationFn: function sandboxGithubRefreshRepositoriesMutationFn({
+      request,
+      options,
+    }): Promise<SandboxGithubRefreshRepositoriesMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(sandboxGithubRefreshRepositories(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/react-query/sandboxGithubResolveReference.ts

@@ -0,0 +1,112 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { SDKCore } from "../core.js";
+import { sandboxGithubResolveReference } from "../funcs/sandboxGithubResolveReference.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useSDKContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type SandboxGithubResolveReferenceMutationVariables = {
+  request: operations.ResolveGitHubReferenceRequest;
+  options?: RequestOptions;
+};
+
+export type SandboxGithubResolveReferenceMutationData =
+  components.ResolvedReference;
+
+export type SandboxGithubResolveReferenceMutationError =
+  | errors.HTTPValidationError
+  | SDKError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+/**
+ * Resolve GitHub Reference
+ *
+ * @remarks
+ * Resolve a Git reference in a connected repository to a commit SHA. Omit `ref` to resolve the repository's default branch.
+ */
+export function useSandboxGithubResolveReferenceMutation(
+  options?: MutationHookOptions<
+    SandboxGithubResolveReferenceMutationData,
+    SandboxGithubResolveReferenceMutationError,
+    SandboxGithubResolveReferenceMutationVariables
+  >,
+): UseMutationResult<
+  SandboxGithubResolveReferenceMutationData,
+  SandboxGithubResolveReferenceMutationError,
+  SandboxGithubResolveReferenceMutationVariables
+> {
+  const client = useSDKContext();
+  return useMutation({
+    ...buildSandboxGithubResolveReferenceMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeySandboxGithubResolveReference(): MutationKey {
+  return ["@meetkai/mka1", "github", "resolveReference"];
+}
+
+export function buildSandboxGithubResolveReferenceMutation(
+  client$: SDKCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: SandboxGithubResolveReferenceMutationVariables,
+  ) => Promise<SandboxGithubResolveReferenceMutationData>;
+} {
+  return {
+    mutationKey: mutationKeySandboxGithubResolveReference(),
+    mutationFn: function sandboxGithubResolveReferenceMutationFn({
+      request,
+      options,
+    }): Promise<SandboxGithubResolveReferenceMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(sandboxGithubResolveReference(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/sdk/environments.ts

@@ -2,14 +2,12 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { flagsEnvironmentsCreate } from "../funcs/flagsEnvironmentsCreate.js";
-import { flagsEnvironmentsDelete } from "../funcs/flagsEnvironmentsDelete.js";
-import { flagsEnvironmentsEvaluate } from "../funcs/flagsEnvironmentsEvaluate.js";
-import { flagsEnvironmentsEvaluateWithTraits } from "../funcs/flagsEnvironmentsEvaluateWithTraits.js";
-import { flagsEnvironmentsGenerateEvaluationKey } from "../funcs/flagsEnvironmentsGenerateEvaluationKey.js";
-import { flagsEnvironmentsList } from "../funcs/flagsEnvironmentsList.js";
-import { flagsEnvironmentsRevokeEvaluationKey } from "../funcs/flagsEnvironmentsRevokeEvaluationKey.js";
-import { flagsEnvironmentsUpdate } from "../funcs/flagsEnvironmentsUpdate.js";
+import { sandboxEnvironmentsCreate } from "../funcs/sandboxEnvironmentsCreate.js";
+import { sandboxEnvironmentsDelete } from "../funcs/sandboxEnvironmentsDelete.js";
+import { sandboxEnvironmentsGet } from "../funcs/sandboxEnvironmentsGet.js";
+import { sandboxEnvironmentsList } from "../funcs/sandboxEnvironmentsList.js";
+import { sandboxEnvironmentsRunSetup } from "../funcs/sandboxEnvironmentsRunSetup.js";
+import { sandboxEnvironmentsUpdate } from "../funcs/sandboxEnvironmentsUpdate.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
@@ -17,13 +15,16 @@ import { unwrapAsync } from "../types/fp.js";
 
 export class Environments extends ClientSDK {
   /**
-   * List environments
+   * List Environments
+   *
+   * @remarks
+   * List the caller's saved environments, plus the per-environment repository limit.
    */
   async list(
-    request: operations.ListFeatureFlagEnvironmentsRequest,
+    request: operations.ListSandboxEnvironmentsRequest,
     options?: RequestOptions,
-  ): Promise<Array<components.FeatureFlagEnvironment>> {
-    return unwrapAsync(flagsEnvironmentsList(
+  ): Promise<components.EnvironmentList> {
+    return unwrapAsync(sandboxEnvironmentsList(
       this,
       request,
       options,
@@ -31,30 +32,16 @@ export class Environments extends ClientSDK {
   }
 
   /**
-   * Create an environment
+   * Create Environment
    *
    * @remarks
-   * Every existing flag gets a disabled state in the new environment.
+   * Save a named environment: repositories to clone, environment variables, network access, and an optional bash setup script. Sessions created from it copy these settings. Do not put secrets in `environment_variables`.
    */
   async create(
-    request: operations.CreateFeatureFlagEnvironmentRequest,
-    options?: RequestOptions,
-  ): Promise<components.FeatureFlagEnvironment> {
-    return unwrapAsync(flagsEnvironmentsCreate(
-      this,
-      request,
-      options,
-    ));
-  }
-
-  /**
-   * Delete an environment and every flag setting in it
-   */
-  async delete(
-    request: operations.DeleteFeatureFlagEnvironmentRequest,
+    request: operations.CreateSandboxEnvironmentRequest,
     options?: RequestOptions,
-  ): Promise<void> {
-    return unwrapAsync(flagsEnvironmentsDelete(
+  ): Promise<components.EnvironmentModel> {
+    return unwrapAsync(sandboxEnvironmentsCreate(
       this,
       request,
       options,
@@ -62,65 +49,50 @@ export class Environments extends ClientSDK {
   }
 
   /**
-   * Rename an environment
-   */
-  async update(
-    request: operations.UpdateFeatureFlagEnvironmentRequest,
-    options?: RequestOptions,
-  ): Promise<components.FeatureFlagEnvironment> {
-    return unwrapAsync(flagsEnvironmentsUpdate(
-      this,
-      request,
-      options,
-    ));
-  }
-
-  /**
-   * Evaluate every flag for an identity
+   * Get Environment
    *
    * @remarks
-   * Resolves every non-archived flag of the environment for an anonymous caller, or for the identity given in the query. Sends an ETag and answers 304 to a matching If-None-Match after authenticating the environment evaluation key.
+   * Return one of the caller's saved environments.
    */
-  async evaluate(
-    security: operations.EvaluateFeatureFlagsSecurity,
-    request: operations.EvaluateFeatureFlagsRequest,
+  async get(
+    request: operations.GetSandboxEnvironmentRequest,
     options?: RequestOptions,
-  ): Promise<operations.EvaluateFeatureFlagsResponse | undefined> {
-    return unwrapAsync(flagsEnvironmentsEvaluate(
+  ): Promise<components.EnvironmentModel> {
+    return unwrapAsync(sandboxEnvironmentsGet(
       this,
-      security,
       request,
       options,
     ));
   }
 
   /**
-   * Evaluate every flag for an identity with traits
+   * Update Environment
+   *
+   * @remarks
+   * Replace a saved environment's settings. Omit `network_access` to keep the stored value. Sessions already created from the environment keep the settings they started with.
    */
-  async evaluateWithTraits(
-    security: operations.EvaluateFeatureFlagsWithTraitsSecurity,
-    request: operations.EvaluateFeatureFlagsWithTraitsRequest,
+  async update(
+    request: operations.UpdateSandboxEnvironmentRequest,
     options?: RequestOptions,
-  ): Promise<components.FeatureFlagEvaluateResponse> {
-    return unwrapAsync(flagsEnvironmentsEvaluateWithTraits(
+  ): Promise<components.EnvironmentModel> {
+    return unwrapAsync(sandboxEnvironmentsUpdate(
       this,
-      security,
       request,
       options,
     ));
   }
 
   /**
-   * Revoke an environment evaluation key
+   * Delete Environment
    *
    * @remarks
-   * Revocation is idempotent while the environment exists.
+   * Delete a saved environment. Sessions already created from it are not affected.
    */
-  async revokeEvaluationKey(
-    request: operations.RevokeFeatureFlagEvaluationKeyRequest,
+  async delete(
+    request: operations.DeleteSandboxEnvironmentRequest,
     options?: RequestOptions,
   ): Promise<void> {
-    return unwrapAsync(flagsEnvironmentsRevokeEvaluationKey(
+    return unwrapAsync(sandboxEnvironmentsDelete(
       this,
       request,
       options,
@@ -128,16 +100,16 @@ export class Environments extends ClientSDK {
   }
 
   /**
-   * Generate or replace an environment evaluation key
+   * Run Environment Setup
    *
    * @remarks
-   * Returns the new plaintext key once. Only its SHA-256 digest and a display hint are stored; generating another key immediately replaces the previous credential on this replica.
+   * Run the setup script of the environment the session was created from. Call it once the session's repositories have cloned. A `running` status means setup has not finished yet and calling again is safe; once setup has succeeded, later calls return `succeeded` without running it again.
    */
-  async generateEvaluationKey(
-    request: operations.GenerateFeatureFlagEvaluationKeyRequest,
+  async runSetup(
+    request: operations.RunSandboxEnvironmentSetupRequest,
     options?: RequestOptions,
-  ): Promise<operations.GenerateFeatureFlagEvaluationKeyResponse> {
-    return unwrapAsync(flagsEnvironmentsGenerateEvaluationKey(
+  ): Promise<components.EnvironmentSetupRunModel> {
+    return unwrapAsync(sandboxEnvironmentsRunSetup(
       this,
       request,
       options,

package/src/sdk/flags.ts

@@ -15,7 +15,7 @@ import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 import { Audit } from "./audit.js";
-import { Environments } from "./environments.js";
+import { SDKEnvironments } from "./sdkenvironments.js";
 
 export class Flags extends ClientSDK {
   private _audit?: Audit;
@@ -23,9 +23,9 @@ export class Flags extends ClientSDK {
     return (this._audit ??= new Audit(this._options));
   }
 
-  private _environments?: Environments;
-  get environments(): Environments {
-    return (this._environments ??= new Environments(this._options));
+  private _environments?: SDKEnvironments;
+  get environments(): SDKEnvironments {
+    return (this._environments ??= new SDKEnvironments(this._options));
   }
 
   /**

package/src/sdk/github.ts

@@ -0,0 +1,244 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { sandboxGithubAddSessionRepository } from "../funcs/sandboxGithubAddSessionRepository.js";
+import { sandboxGithubCloneRepository } from "../funcs/sandboxGithubCloneRepository.js";
+import { sandboxGithubConnect } from "../funcs/sandboxGithubConnect.js";
+import { sandboxGithubCreateAuthorizationIntent } from "../funcs/sandboxGithubCreateAuthorizationIntent.js";
+import { sandboxGithubCreateOrUpdatePullRequest } from "../funcs/sandboxGithubCreateOrUpdatePullRequest.js";
+import { sandboxGithubDisconnect } from "../funcs/sandboxGithubDisconnect.js";
+import { sandboxGithubDismissSessionRepository } from "../funcs/sandboxGithubDismissSessionRepository.js";
+import { sandboxGithubGetConnection } from "../funcs/sandboxGithubGetConnection.js";
+import { sandboxGithubListRepositories } from "../funcs/sandboxGithubListRepositories.js";
+import { sandboxGithubListSessionRepositories } from "../funcs/sandboxGithubListSessionRepositories.js";
+import { sandboxGithubPush } from "../funcs/sandboxGithubPush.js";
+import { sandboxGithubRefreshRepositories } from "../funcs/sandboxGithubRefreshRepositories.js";
+import { sandboxGithubResolveReference } from "../funcs/sandboxGithubResolveReference.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Github extends ClientSDK {
+  /**
+   * Start GitHub Authorization
+   *
+   * @remarks
+   * Start connecting the caller's GitHub account. Send the user to the returned `authorize_url`. GitHub redirects back with a `code` and the same `state`; pass both to `POST /github/oauth/connections` before `expires_in_seconds` elapses. Each `state` works once.
+   */
+  async createAuthorizationIntent(
+    request: operations.CreateGitHubAuthorizationIntentRequest,
+    options?: RequestOptions,
+  ): Promise<components.AuthorizeIntent> {
+    return unwrapAsync(sandboxGithubCreateAuthorizationIntent(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Connect GitHub Account
+   *
+   * @remarks
+   * Finish GitHub authorization by exchanging the `code` and `state` from GitHub's redirect for a stored connection. The sandbox service keeps the access token encrypted and never returns it. The response lists the repositories the connection can reach.
+   */
+  async connect(
+    request: operations.ConnectGitHubAccountRequest,
+    options?: RequestOptions,
+  ): Promise<components.Connection> {
+    return unwrapAsync(sandboxGithubConnect(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get GitHub Connection
+   *
+   * @remarks
+   * Return the caller's GitHub connection, or `null` when there is none. `token_invalid_at` is set once GitHub has rejected the stored token; reconnect to fix it. Set `verify` to `true` to check the token with GitHub now instead of at its next use.
+   */
+  async getConnection(
+    request: operations.GetGitHubConnectionRequest,
+    options?: RequestOptions,
+  ): Promise<components.ConnectionEnvelope> {
+    return unwrapAsync(sandboxGithubGetConnection(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Disconnect GitHub Account
+   *
+   * @remarks
+   * Delete the caller's GitHub connection and revoke its token at GitHub. The connection is deleted even if GitHub does not confirm the revocation.
+   */
+  async disconnect(
+    request: operations.DisconnectGitHubAccountRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(sandboxGithubDisconnect(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List GitHub Repositories
+   *
+   * @remarks
+   * List the repositories recorded for the caller's GitHub connection, or an empty list when there is no connection. The list is captured when you connect; call `POST /github/repositories/refresh` to update it.
+   */
+  async listRepositories(
+    request: operations.ListGitHubRepositoriesRequest,
+    options?: RequestOptions,
+  ): Promise<components.RepositoryList> {
+    return unwrapAsync(sandboxGithubListRepositories(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Refresh GitHub Repositories
+   *
+   * @remarks
+   * Re-read the repositories the caller's GitHub connection can reach, save them as the connection's repository list, and return it.
+   */
+  async refreshRepositories(
+    request: operations.RefreshGitHubRepositoriesRequest,
+    options?: RequestOptions,
+  ): Promise<components.RepositoryList> {
+    return unwrapAsync(sandboxGithubRefreshRepositories(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Resolve GitHub Reference
+   *
+   * @remarks
+   * Resolve a Git reference in a connected repository to a commit SHA. Omit `ref` to resolve the repository's default branch.
+   */
+  async resolveReference(
+    request: operations.ResolveGitHubReferenceRequest,
+    options?: RequestOptions,
+  ): Promise<components.ResolvedReference> {
+    return unwrapAsync(sandboxGithubResolveReference(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Clone GitHub Repository into Session
+   *
+   * @remarks
+   * Clone a connected repository at `base_sha` into the session workspace using the caller's GitHub connection. The sandbox host runs the clone, so the token never enters the session.
+   */
+  async cloneRepository(
+    request: operations.CloneGitHubRepositoryIntoSessionRequest,
+    options?: RequestOptions,
+  ): Promise<components.GitHubReadCloneResult> {
+    return unwrapAsync(sandboxGithubCloneRepository(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List Session Repositories
+   *
+   * @remarks
+   * Return the repositories added to the session with each one's ref, checkout path, clone status, last push, and pull request, plus the per-session repository limit.
+   */
+  async listSessionRepositories(
+    request: operations.ListSessionGitHubRepositoriesRequest,
+    options?: RequestOptions,
+  ): Promise<components.SessionRepositoryManifest> {
+    return unwrapAsync(sandboxGithubListSessionRepositories(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Add Session Repository
+   *
+   * @remarks
+   * Add a connected repository to the session and clone it at `ref`, or at the default branch when `ref` is omitted. Repeating the same request is safe. After a successful clone the repository's ref cannot change.
+   */
+  async addSessionRepository(
+    request: operations.AddSessionGitHubRepositoryRequest,
+    options?: RequestOptions,
+  ): Promise<components.SessionRepositoryModel> {
+    return unwrapAsync(sandboxGithubAddSessionRepository(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Dismiss Failed Session Repository
+   *
+   * @remarks
+   * Remove a repository whose clone failed from the session. A repository that cloned successfully, or whose clone is still in progress, cannot be removed.
+   */
+  async dismissSessionRepository(
+    request: operations.DismissSessionGitHubRepositoryRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(sandboxGithubDismissSessionRepository(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Push Session to GitHub
+   *
+   * @remarks
+   * Push the session's checkout to `branch` in the repository it was cloned from, using the caller's GitHub connection. The repository always comes from the session, never from the request. Set `checkout_path` when the repository is not at the workspace root.
+   */
+  async push(
+    request: operations.PushSessionToGitHubRequest,
+    options?: RequestOptions,
+  ): Promise<components.GitHubPushResult> {
+    return unwrapAsync(sandboxGithubPush(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create or Update Pull Request
+   *
+   * @remarks
+   * Open a pull request from `branch` in the session's repository, or update the one already recorded for that branch, reopening it if it was closed. The base defaults to the repository's default branch. A merged pull request is never reopened; a later call for the same branch opens a new one. The session does not need to be running.
+   */
+  async createOrUpdatePullRequest(
+    request: operations.CreateOrUpdateSessionPullRequestRequest,
+    options?: RequestOptions,
+  ): Promise<components.GitHubPullRequestResult> {
+    return unwrapAsync(sandboxGithubCreateOrUpdatePullRequest(
+      this,
+      request,
+      options,
+    ));
+  }
+}