@distilled.cloud/daytona 0.0.0-placeholder → 1.0.0-rc.13

package/src/services/git.ts

@@ -0,0 +1,928 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+/** files to add (use . for all files) */
+export type AddFilesRequestFilesList = Array<string>;
+export const AddFilesRequestFilesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<AddFilesRequestFilesList>;
+
+export interface AddFilesRequest {
+  /** files to add (use . for all files) */
+  files: AddFilesRequestFilesList;
+  path: string;
+}
+export const AddFilesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    files: AddFilesRequestFilesList,
+    path: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/git/add", code: 200 })),
+).annotate({
+  identifier: "AddFilesRequest",
+}) as any as S.Schema<AddFilesRequest>;
+
+export interface AddFilesResponse {}
+export const AddFilesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AddFilesResponse",
+}) as any as S.Schema<AddFilesResponse>;
+
+export interface AddRemoteRequest {
+  /** Fetch fetches from the remote immediately after adding it. */
+  fetch?: boolean;
+  name: string;
+  /** Overwrite replaces an existing remote with the same name. */
+  overwrite?: boolean;
+  path: string;
+  url: string;
+}
+export const AddRemoteRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    fetch: S.optional(S.Boolean),
+    name: S.String,
+    overwrite: S.optional(S.Boolean),
+    path: S.String,
+    url: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/git/remotes", code: 200 })),
+).annotate({
+  identifier: "AddRemoteRequest",
+}) as any as S.Schema<AddRemoteRequest>;
+
+export interface AddRemoteResponse {}
+export const AddRemoteResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AddRemoteResponse",
+}) as any as S.Schema<AddRemoteResponse>;
+
+export interface AuthenticateRequest {
+  /** Host defaults to github.com. */
+  host?: string;
+  password: string | Redacted.Redacted<string>;
+  /** Protocol defaults to https. */
+  protocol?: string;
+  username: string;
+}
+export const AuthenticateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    host: S.optional(S.String),
+    password: S.String.pipe(T.SensitiveValue({})),
+    protocol: S.optional(S.String),
+    username: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/git/credentials", code: 200 })),
+).annotate({
+  identifier: "AuthenticateRequest",
+}) as any as S.Schema<AuthenticateRequest>;
+
+export interface AuthenticateResponse {}
+export const AuthenticateResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "AuthenticateResponse",
+}) as any as S.Schema<AuthenticateResponse>;
+
+export interface CheckoutBranchRequest {
+  branch: string;
+  path: string;
+}
+export const CheckoutBranchRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    branch: S.String,
+    path: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/git/checkout", code: 200 })),
+).annotate({
+  identifier: "CheckoutBranchRequest",
+}) as any as S.Schema<CheckoutBranchRequest>;
+
+export interface CheckoutBranchResponse {}
+export const CheckoutBranchResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CheckoutBranchResponse",
+}) as any as S.Schema<CheckoutBranchResponse>;
+
+export interface CloneRepositoryRequest {
+  branch?: string;
+  commit_id?: string;
+  /** Depth creates a shallow clone truncated to the given number of commits. */
+  depth?: number;
+  /** Skip TLS certificate verification for this clone. Defaults to false (verify). Set to true ONLY for trusted internal Git servers with self-signed or private-CA certs; credentials, if supplied, will be transmitted over an unverified TLS connection and are exposed to any MITM on the route. */
+  insecure_skip_tls?: boolean;
+  password?: string | Redacted.Redacted<string>;
+  path: string;
+  url: string;
+  username?: string;
+}
+export const CloneRepositoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    branch: S.optional(S.String),
+    commit_id: S.optional(S.String),
+    depth: S.optional(S.Number),
+    insecure_skip_tls: S.optional(S.Boolean),
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    path: S.String,
+    url: S.String,
+    username: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/git/clone", code: 200 })),
+).annotate({
+  identifier: "CloneRepositoryRequest",
+}) as any as S.Schema<CloneRepositoryRequest>;
+
+export interface CloneRepositoryResponse {}
+export const CloneRepositoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CloneRepositoryResponse",
+}) as any as S.Schema<CloneRepositoryResponse>;
+
+export interface CommitChangesRequest {
+  allow_empty?: boolean;
+  author: string;
+  email: string;
+  message: string;
+  path: string;
+}
+export const CommitChangesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allow_empty: S.optional(S.Boolean),
+    author: S.String,
+    email: S.String,
+    message: S.String,
+    path: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/git/commit", code: 200 })),
+).annotate({
+  identifier: "CommitChangesRequest",
+}) as any as S.Schema<CommitChangesRequest>;
+
+export interface GitCommitResponse {
+  hash: string;
+}
+export const GitCommitResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    hash: S.String,
+  }),
+).annotate({
+  identifier: "GitCommitResponse",
+}) as any as S.Schema<GitCommitResponse>;
+
+export interface ConfigureUserRequest {
+  email: string;
+  name: string;
+  /** Path is the repository path, required when scope is "local". */
+  path?: string;
+  /** Scope is one of global (default), local or system. */
+  scope?: string;
+}
+export const ConfigureUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    email: S.String,
+    name: S.String,
+    path: S.optional(S.String),
+    scope: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/git/config/user", code: 200 })),
+).annotate({
+  identifier: "ConfigureUserRequest",
+}) as any as S.Schema<ConfigureUserRequest>;
+
+export interface ConfigureUserResponse {}
+export const ConfigureUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "ConfigureUserResponse",
+}) as any as S.Schema<ConfigureUserResponse>;
+
+export interface CreateBranchRequest {
+  name: string;
+  path: string;
+}
+export const CreateBranchRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String,
+    path: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/git/branches", code: 200 })),
+).annotate({
+  identifier: "CreateBranchRequest",
+}) as any as S.Schema<CreateBranchRequest>;
+
+export interface CreateBranchResponse {}
+export const CreateBranchResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateBranchResponse",
+}) as any as S.Schema<CreateBranchResponse>;
+
+export interface DeleteBranchRequest {
+  name: string;
+  path: string;
+}
+export const DeleteBranchRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String,
+    path: S.String,
+  }).pipe(T.Http({ method: "DELETE", uri: "/git/branches", code: 200 })),
+).annotate({
+  identifier: "DeleteBranchRequest",
+}) as any as S.Schema<DeleteBranchRequest>;
+
+export interface DeleteBranchResponse {}
+export const DeleteBranchResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteBranchResponse",
+}) as any as S.Schema<DeleteBranchResponse>;
+
+export interface GetCommitHistoryRequest {
+  /** Repository path */
+  path: string;
+}
+export const GetCommitHistoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/git/history", code: 200 })),
+).annotate({
+  identifier: "GetCommitHistoryRequest",
+}) as any as S.Schema<GetCommitHistoryRequest>;
+
+export interface GitCommitInfo {
+  author: string;
+  email: string;
+  hash: string;
+  message: string;
+  timestamp: string;
+}
+export const GitCommitInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    author: S.String,
+    email: S.String,
+    hash: S.String,
+    message: S.String,
+    timestamp: S.String,
+  }),
+).annotate({ identifier: "GitCommitInfo" }) as any as S.Schema<GitCommitInfo>;
+
+export type GetCommitHistoryResponseBodyList = Array<GitCommitInfo>;
+export const GetCommitHistoryResponseBodyList = /*@__PURE__*/ S.Array(
+  GitCommitInfo,
+) as any as S.Schema<GetCommitHistoryResponseBodyList>;
+
+export type GetCommitHistoryResponse = GetCommitHistoryResponseBodyList;
+export const GetCommitHistoryResponse = /*@__PURE__*/ S.suspend(() =>
+  GetCommitHistoryResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetCommitHistoryResponse",
+}) as any as S.Schema<GetCommitHistoryResponse>;
+
+export interface GetGitConfigRequest {
+  /** Config key (e.g. user.name) */
+  key: string;
+  /** Repository path (required for local scope) */
+  path?: string;
+  /** Config scope: global (default), local or system */
+  scope?: string;
+}
+export const GetGitConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key: S.String.pipe(T.Query()),
+    path: S.optional(S.String.pipe(T.Query())),
+    scope: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/git/config", code: 200 })),
+).annotate({
+  identifier: "GetGitConfigRequest",
+}) as any as S.Schema<GetGitConfigRequest>;
+
+export interface GitConfigResponse {
+  /** Value is the config value, null when the key is not set. */
+  value?: string;
+}
+export const GitConfigResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    value: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GitConfigResponse",
+}) as any as S.Schema<GitConfigResponse>;
+
+export interface GetStatusRequest {
+  /** Repository path */
+  path: string;
+}
+export const GetStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/git/status", code: 200 })),
+).annotate({
+  identifier: "GetStatusRequest",
+}) as any as S.Schema<GetStatusRequest>;
+
+export type Status =
+  | "Unmodified"
+  | "Untracked"
+  | "Modified"
+  | "Added"
+  | "Deleted"
+  | "Renamed"
+  | "Copied"
+  | "Updated but unmerged";
+export const Status = S.String;
+
+export interface FileStatus {
+  extra: string;
+  name: string;
+  staging: Status;
+  worktree: Status;
+}
+export const FileStatus = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    extra: S.String,
+    name: S.String,
+    staging: Status,
+    worktree: Status,
+  }),
+).annotate({ identifier: "FileStatus" }) as any as S.Schema<FileStatus>;
+
+export type GitStatusFileStatusList = Array<FileStatus>;
+export const GitStatusFileStatusList = /*@__PURE__*/ S.Array(
+  FileStatus,
+) as any as S.Schema<GitStatusFileStatusList>;
+
+export interface GitStatus {
+  ahead?: number;
+  behind?: number;
+  branchPublished?: boolean;
+  currentBranch: string;
+  /** Detached is true when HEAD is not on a branch (detached HEAD state). */
+  detached?: boolean;
+  fileStatus: GitStatusFileStatusList;
+  /** Upstream is the upstream tracking branch (e.g. "origin/main"), empty when unset. */
+  upstream?: string;
+}
+export const GitStatus = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ahead: S.optional(S.Number),
+    behind: S.optional(S.Number),
+    branchPublished: S.optional(S.Boolean),
+    currentBranch: S.String,
+    detached: S.optional(S.Boolean),
+    fileStatus: GitStatusFileStatusList,
+    upstream: S.optional(S.String),
+  }),
+).annotate({ identifier: "GitStatus" }) as any as S.Schema<GitStatus>;
+
+export interface InitRepositoryRequest {
+  /** Bare creates a repository without a working tree. */
+  bare?: boolean;
+  /** InitialBranch sets the name of the initial branch. */
+  initial_branch?: string;
+  path: string;
+}
+export const InitRepositoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    bare: S.optional(S.Boolean),
+    initial_branch: S.optional(S.String),
+    path: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/git/init", code: 200 })),
+).annotate({
+  identifier: "InitRepositoryRequest",
+}) as any as S.Schema<InitRepositoryRequest>;
+
+export interface InitRepositoryResponse {}
+export const InitRepositoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "InitRepositoryResponse",
+}) as any as S.Schema<InitRepositoryResponse>;
+
+export interface ListBranchesRequest {
+  /** Repository path */
+  path: string;
+}
+export const ListBranchesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/git/branches", code: 200 })),
+).annotate({
+  identifier: "ListBranchesRequest",
+}) as any as S.Schema<ListBranchesRequest>;
+
+export type ListBranchResponseBranchesList = Array<string>;
+export const ListBranchResponseBranchesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListBranchResponseBranchesList>;
+
+export interface ListBranchResponse {
+  branches: ListBranchResponseBranchesList;
+  /** Current is the name of the checked out branch (empty when HEAD is detached). */
+  current?: string;
+}
+export const ListBranchResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    branches: ListBranchResponseBranchesList,
+    current: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ListBranchResponse",
+}) as any as S.Schema<ListBranchResponse>;
+
+export interface ListRemotesRequest {
+  /** Repository path */
+  path: string;
+}
+export const ListRemotesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/git/remotes", code: 200 })),
+).annotate({
+  identifier: "ListRemotesRequest",
+}) as any as S.Schema<ListRemotesRequest>;
+
+export interface GitRemote {
+  name: string;
+  url: string;
+}
+export const GitRemote = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String,
+    url: S.String,
+  }),
+).annotate({ identifier: "GitRemote" }) as any as S.Schema<GitRemote>;
+
+export type ListRemotesResponseRemotesList = Array<GitRemote>;
+export const ListRemotesResponseRemotesList = /*@__PURE__*/ S.Array(
+  GitRemote,
+) as any as S.Schema<ListRemotesResponseRemotesList>;
+
+export interface ListRemotesResponse {
+  remotes: ListRemotesResponseRemotesList;
+}
+export const ListRemotesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    remotes: ListRemotesResponseRemotesList,
+  }),
+).annotate({
+  identifier: "ListRemotesResponse",
+}) as any as S.Schema<ListRemotesResponse>;
+
+export interface PullChangesRequest {
+  /** Branch to pull (defaults to the current branch's upstream). */
+  branch?: string;
+  password?: string | Redacted.Redacted<string>;
+  path: string;
+  /** Remote to pull from (defaults to "origin"). */
+  remote?: string;
+  username?: string;
+}
+export const PullChangesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    branch: S.optional(S.String),
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    path: S.String,
+    remote: S.optional(S.String),
+    username: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/git/pull", code: 200 })),
+).annotate({
+  identifier: "PullChangesRequest",
+}) as any as S.Schema<PullChangesRequest>;
+
+export interface PullChangesResponse {}
+export const PullChangesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PullChangesResponse",
+}) as any as S.Schema<PullChangesResponse>;
+
+export interface PushChangesRequest {
+  /** Branch to push (defaults to the current branch). */
+  branch?: string;
+  password?: string | Redacted.Redacted<string>;
+  path: string;
+  /** Remote to push to (defaults to "origin"). */
+  remote?: string;
+  /** SetUpstream records the pushed branch as the upstream tracking branch. */
+  set_upstream?: boolean;
+  username?: string;
+}
+export const PushChangesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    branch: S.optional(S.String),
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    path: S.String,
+    remote: S.optional(S.String),
+    set_upstream: S.optional(S.Boolean),
+    username: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/git/push", code: 200 })),
+).annotate({
+  identifier: "PushChangesRequest",
+}) as any as S.Schema<PushChangesRequest>;
+
+export interface PushChangesResponse {}
+export const PushChangesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "PushChangesResponse",
+}) as any as S.Schema<PushChangesResponse>;
+
+/** Files constrains the reset to the given paths. */
+export type ResetChangesRequestFilesList = Array<string>;
+export const ResetChangesRequestFilesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ResetChangesRequestFilesList>;
+
+export interface ResetChangesRequest {
+  /** Files constrains the reset to the given paths. */
+  files?: ResetChangesRequestFilesList;
+  /** Mode is one of soft, mixed (default), hard, merge or keep. */
+  mode?: string;
+  path: string;
+  /** Target is the revision to reset to (defaults to HEAD). */
+  target?: string;
+}
+export const ResetChangesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    files: S.optional(ResetChangesRequestFilesList),
+    mode: S.optional(S.String),
+    path: S.String,
+    target: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/git/reset", code: 200 })),
+).annotate({
+  identifier: "ResetChangesRequest",
+}) as any as S.Schema<ResetChangesRequest>;
+
+export interface ResetChangesResponse {}
+export const ResetChangesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "ResetChangesResponse",
+}) as any as S.Schema<ResetChangesResponse>;
+
+export type RestoreFilesRequestFilesList = Array<string>;
+export const RestoreFilesRequestFilesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RestoreFilesRequestFilesList>;
+
+export interface RestoreFilesRequest {
+  files: RestoreFilesRequestFilesList;
+  path: string;
+  /** Source restores file contents from the given revision instead of the index. */
+  source?: string;
+  /** Staged restores the staging index for the given files. */
+  staged?: boolean;
+  /** Worktree restores the working tree for the given files. */
+  worktree?: boolean;
+}
+export const RestoreFilesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    files: RestoreFilesRequestFilesList,
+    path: S.String,
+    source: S.optional(S.String),
+    staged: S.optional(S.Boolean),
+    worktree: S.optional(S.Boolean),
+  }).pipe(T.Http({ method: "POST", uri: "/git/restore", code: 200 })),
+).annotate({
+  identifier: "RestoreFilesRequest",
+}) as any as S.Schema<RestoreFilesRequest>;
+
+export interface RestoreFilesResponse {}
+export const RestoreFilesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RestoreFilesResponse",
+}) as any as S.Schema<RestoreFilesResponse>;
+
+export interface SetGitConfigRequest {
+  key: string;
+  /** Path is the repository path, required when scope is "local". */
+  path?: string;
+  /** Scope is one of global (default), local or system. */
+  scope?: string;
+  value: string;
+}
+export const SetGitConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key: S.String,
+    path: S.optional(S.String),
+    scope: S.optional(S.String),
+    value: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/git/config", code: 200 })),
+).annotate({
+  identifier: "SetGitConfigRequest",
+}) as any as S.Schema<SetGitConfigRequest>;
+
+export interface SetGitConfigResponse {}
+export const SetGitConfigResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "SetGitConfigResponse",
+}) as any as S.Schema<SetGitConfigResponse>;
+
+export type AddFilesError = DaytonaOpError;
+/** Add files to Git staging Add files to the Git staging area */
+export const addFiles: API.OperationMethod<
+  AddFilesRequest,
+  AddFilesResponse,
+  AddFilesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AddFilesRequest,
+  output: AddFilesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AddRemoteError = DaytonaOpError;
+/** Add a remote Add (or overwrite) a remote in the Git repository */
+export const addRemote: API.OperationMethod<
+  AddRemoteRequest,
+  AddRemoteResponse,
+  AddRemoteError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AddRemoteRequest,
+  output: AddRemoteResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type AuthenticateError = DaytonaOpError;
+/** Authenticate Git Persist Git credentials globally via the credential store. Stores the password in plaintext on disk. */
+export const authenticate: API.OperationMethod<
+  AuthenticateRequest,
+  AuthenticateResponse,
+  AuthenticateError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AuthenticateRequest,
+  output: AuthenticateResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CheckoutBranchError = DaytonaOpError;
+/** Checkout branch or commit Switch to a different branch or commit in the Git repository */
+export const checkoutBranch: API.OperationMethod<
+  CheckoutBranchRequest,
+  CheckoutBranchResponse,
+  CheckoutBranchError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CheckoutBranchRequest,
+  output: CheckoutBranchResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CloneRepositoryError = DaytonaOpError;
+/** Clone a Git repository Clone a Git repository to the specified path. Defaults to strict TLS verification; set insecure_skip_tls=true to skip verification for self-signed or private-CA Git servers. */
+export const cloneRepository: API.OperationMethod<
+  CloneRepositoryRequest,
+  CloneRepositoryResponse,
+  CloneRepositoryError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CloneRepositoryRequest,
+  output: CloneRepositoryResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CommitChangesError = DaytonaOpError;
+/** Commit changes Commit staged changes to the Git repository */
+export const commitChanges: API.OperationMethod<
+  CommitChangesRequest,
+  GitCommitResponse,
+  CommitChangesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CommitChangesRequest,
+  output: GitCommitResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ConfigureUserError = DaytonaOpError;
+/** Configure Git user Configure the Git user name and email at the given scope */
+export const configureUser: API.OperationMethod<
+  ConfigureUserRequest,
+  ConfigureUserResponse,
+  ConfigureUserError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ConfigureUserRequest,
+  output: ConfigureUserResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateBranchError = DaytonaOpError;
+/** Create a new branch Create a new branch in the Git repository */
+export const createBranch: API.OperationMethod<
+  CreateBranchRequest,
+  CreateBranchResponse,
+  CreateBranchError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateBranchRequest,
+  output: CreateBranchResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteBranchError = DaytonaOpError;
+/** Delete a branch Delete a branch from the Git repository */
+export const deleteBranch: API.OperationMethod<
+  DeleteBranchRequest,
+  DeleteBranchResponse,
+  DeleteBranchError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteBranchRequest,
+  output: DeleteBranchResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetCommitHistoryError = DaytonaOpError;
+/** Get commit history Get the commit history of the Git repository */
+export const getCommitHistory: API.OperationMethod<
+  GetCommitHistoryRequest,
+  GetCommitHistoryResponse,
+  GetCommitHistoryError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCommitHistoryRequest,
+  output: GetCommitHistoryResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetGitConfigError = DaytonaOpError;
+/** Get a Git config value Get a Git config value at the given scope (null when unset) */
+export const getGitConfig: API.OperationMethod<
+  GetGitConfigRequest,
+  GitConfigResponse,
+  GetGitConfigError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetGitConfigRequest,
+  output: GitConfigResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetStatusError = DaytonaOpError;
+/** Get Git status Get the Git status of the repository at the specified path */
+export const getStatus: API.OperationMethod<
+  GetStatusRequest,
+  GitStatus,
+  GetStatusError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetStatusRequest,
+  output: GitStatus,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type InitRepositoryError = DaytonaOpError;
+/** Initialize a Git repository Initialize a new Git repository at the specified path */
+export const initRepository: API.OperationMethod<
+  InitRepositoryRequest,
+  InitRepositoryResponse,
+  InitRepositoryError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: InitRepositoryRequest,
+  output: InitRepositoryResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListBranchesError = DaytonaOpError;
+/** List branches Get a list of all branches in the Git repository */
+export const listBranches: API.OperationMethod<
+  ListBranchesRequest,
+  ListBranchResponse,
+  ListBranchesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListBranchesRequest,
+  output: ListBranchResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListRemotesError = DaytonaOpError;
+/** List remotes List the remotes configured in the Git repository */
+export const listRemotes: API.OperationMethod<
+  ListRemotesRequest,
+  ListRemotesResponse,
+  ListRemotesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListRemotesRequest,
+  output: ListRemotesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PullChangesError = DaytonaOpError;
+/** Pull changes from remote Pull changes from the remote Git repository */
+export const pullChanges: API.OperationMethod<
+  PullChangesRequest,
+  PullChangesResponse,
+  PullChangesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PullChangesRequest,
+  output: PullChangesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PushChangesError = DaytonaOpError;
+/** Push changes to remote Push local changes to the remote Git repository */
+export const pushChanges: API.OperationMethod<
+  PushChangesRequest,
+  PushChangesResponse,
+  PushChangesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PushChangesRequest,
+  output: PushChangesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ResetChangesError = DaytonaOpError;
+/** Reset repository Reset the current HEAD to the specified state */
+export const resetChanges: API.OperationMethod<
+  ResetChangesRequest,
+  ResetChangesResponse,
+  ResetChangesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ResetChangesRequest,
+  output: ResetChangesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreFilesError = DaytonaOpError;
+/** Restore files Restore working tree files or unstage changes */
+export const restoreFiles: API.OperationMethod<
+  RestoreFilesRequest,
+  RestoreFilesResponse,
+  RestoreFilesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreFilesRequest,
+  output: RestoreFilesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SetGitConfigError = DaytonaOpError;
+/** Set a Git config value Set a Git config key/value at the given scope */
+export const setGitConfig: API.OperationMethod<
+  SetGitConfigRequest,
+  SetGitConfigResponse,
+  SetGitConfigError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SetGitConfigRequest,
+  output: SetGitConfigResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));