@effected/github-actions 0.35.0 → 0.36.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (46) hide show
  1. package/Action.js +7 -7
  2. package/ActionCache.js +4 -4
  3. package/ActionEnvironment.js +1 -1
  4. package/ActionInput.js +1 -1
  5. package/ActionLogger.js +197 -64
  6. package/ActionManifest.js +2 -2
  7. package/ActionOutputs.js +2 -2
  8. package/ActionState.js +1 -1
  9. package/ActionsIdentityToken.js +2 -2
  10. package/ActionsProvenance.js +2 -2
  11. package/ActionsRegistryCredential.js +2 -2
  12. package/Artifact.js +3 -3
  13. package/BlobStore.githubCache.js +2 -2
  14. package/BlobStore.js +4 -4
  15. package/CacheKey.js +2 -2
  16. package/CheckDocument.js +1 -1
  17. package/Checkout.js +361 -0
  18. package/DetachedProcess.js +4 -4
  19. package/DryRun.js +1 -1
  20. package/GitHubMarkdown.js +1 -1
  21. package/GitHubToken.js +2 -2
  22. package/ManagedDocument.js +1 -1
  23. package/OidcTokenIssuer.js +7 -7
  24. package/PackageManagerInstaller.js +3 -3
  25. package/README.md +2 -1
  26. package/Secret.js +1 -1
  27. package/ToolInstaller.js +4 -4
  28. package/index.d.ts +569 -103
  29. package/index.js +3 -2
  30. package/internal/actionsResults.js +1 -1
  31. package/internal/blobCause.js +1 -1
  32. package/internal/blobTransport.js +2 -2
  33. package/internal/cacheService.js +1 -1
  34. package/internal/checkout/asciiTrim.js +18 -0
  35. package/internal/checkout/credentials.js +563 -0
  36. package/internal/checkout/directory.js +119 -0
  37. package/internal/checkout/inputs.js +130 -0
  38. package/internal/checkout/refs.js +143 -0
  39. package/internal/checkout/settings.js +144 -0
  40. package/internal/checkout/source.js +418 -0
  41. package/internal/checkout/unsafePullRequest.js +62 -0
  42. package/internal/digest.js +1 -1
  43. package/internal/pnpmExe.js +1 -1
  44. package/internal/stepLog.js +225 -0
  45. package/internal/twirp.js +1 -1
  46. package/package.json +2 -1
package/index.d.ts CHANGED
@@ -21,16 +21,17 @@
21
21
  *
22
22
  * @packageDocumentation
23
23
  */
24
- import { AnnotationProperties, AnnotationProperties as AnnotationProperties$1, WorkflowCommand } from "@effected/github-commands";
24
+ import { Cause, Config, ConfigProvider, Context, Duration, Effect, FileSystem, Layer, Logger, Option, Path, PlatformError, Redacted, Result, Schema, SchemaAST, Scope } from "effect";
25
25
  import * as NodeServices from "@effect/platform-node/NodeServices";
26
- import { Cause, Config, ConfigProvider, Context, Duration, Effect, FileSystem, Layer, Logger, Option, Path, Redacted, Result, Schema, SchemaAST } from "effect";
27
26
  import { Digest, Mac, SecureRandom, Signature } from "effect/crypto";
28
27
  import { HttpClient } from "effect/http";
29
- import { ChildProcessSpawner } from "effect/process";
28
+ import { AnnotationProperties, AnnotationProperties as AnnotationProperties$1, WorkflowCommand } from "@effected/github-commands";
29
+ import { ChildProcess, ChildProcessSpawner } from "effect/process";
30
30
  import { IdentityToken } from "@effected/oidc";
31
31
  import { ActionsOidcClaims, BotIdentity, GitHubApp, GitHubClient, InstallationToken, PermissionLevel, RetryPolicy } from "@effected/github";
32
32
  import { SlsaProvenance } from "@effected/sbom";
33
33
  import { IntegrityHashBrand, PackageManagerPin, WorkloadCredential } from "@effected/npm";
34
+ import { Git, GitCommandError, NotARepositoryError, UnknownRefError } from "@effected/git";
34
35
  declare const ActionEnvironmentError_base: Schema.Class<ActionEnvironmentError, Schema.TaggedStruct<"ActionEnvironmentError", {
35
36
  /** `missing` — absent or empty; `malformed` — present but unusable. */
36
37
  readonly reason: Schema.Literals<readonly ["missing", "malformed"]>;
@@ -284,41 +285,38 @@ export declare class ActionEnvironment extends ActionEnvironment_base {
284
285
  static readonly layerTest: (overrides?: Readonly<Record<string, string>>, payload?: unknown) => Layer.Layer<ActionEnvironment>;
285
286
  }
286
287
  /**
287
- * Options for {@link ActionLoggerShape.withBuffer}.
288
+ * Options for {@link ActionLoggerShape.step}.
288
289
  *
289
290
  * @public
290
291
  */
291
- interface WithBufferOptions {
292
+ interface StepOptions<A> {
292
293
  /**
293
- * What happens to the captured transcript when the step **succeeds**.
294
+ * How long the step may run before its detail streams live instead of folding.
294
295
  *
295
296
  * @remarks
296
- * `"flush"` — the default — replays it, so a clean run still prints what it
297
- * did. `"discard"` drops it, which is what keeps a green release log to one
298
- * line per step: the transcript exists only as the failure report. A failure,
299
- * a defect or an interruption flushes under either setting — the choice is
300
- * only about what a success is worth in the log.
297
+ * Only the outermost open step's window counts; a step nested inside another ignores its own.
301
298
  */
302
- readonly onSuccess?: "flush" | "discard";
303
- }
304
- /**
305
- * Options for {@link ActionLoggerShape.withStep}.
306
- *
307
- * @public
308
- */
309
- interface WithStepOptions {
299
+ readonly window?: Duration.Input;
300
+ /**
301
+ * The result line's text when the step succeeds, computed from its result.
302
+ *
303
+ * @remarks
304
+ * Defaults to the step's name, which is also the text when the function throws.
305
+ */
306
+ readonly summary?: (result: A) => string;
310
307
  /**
311
- * The info line emitted when the step **succeeds**.
308
+ * The result line's text when the step fails, computed from its failure.
312
309
  *
313
310
  * @remarks
314
- * Defaults to `✅ <name>`. This is the line the buffered transcript is traded
315
- * for: a green step reports that it happened and nothing else.
311
+ * Replaces both the name and the message. Defaults to `<name> · <message>`, the message being the first line of the
312
+ * squashed failure's message, which is also the text when the function throws. An interruption always reads
313
+ * `<name> · interrupted`.
316
314
  */
317
- readonly summary?: string;
315
+ readonly failure?: (cause: Cause.Cause<unknown>) => string;
318
316
  }
319
317
  /**
320
- * The members of the {@link ActionLogger} service: log groups and headings,
321
- * buffered steps, notices and source annotations.
318
+ * The members of the {@link ActionLogger} service: log groups, phases, steps,
319
+ * notices and source annotations.
322
320
  *
323
321
  * @public
324
322
  */
@@ -332,12 +330,9 @@ interface ActionLoggerShape {
332
330
  * `::group::` / `::endgroup::` pair, and a call made inside it writes one
333
331
  * `▸ <name>` header line inside the open group instead (line breaks
334
332
  * collapsed to spaces, the text neutralized so it cannot be a command). The
335
- * header goes out through `Console` like the group command it replaces, so
336
- * it is never captured into, or discarded with, an enclosing `withBuffer`
337
- * or `withStep` transcript. A failure at any depth flushes the active
338
- * buffer before the group closes. That ordering is visible in a failed
339
- * run's log: the replayed transcript lands BELOW every nested header that
340
- * was written live, including lines that were logged before the header.
333
+ * header is a line of that step's detail when written inside a
334
+ * {@link ActionLoggerShape.step}, where the depth is already at least 1, and
335
+ * goes out through `Console` otherwise.
341
336
  *
342
337
  * The depth is fiber-scoped, which leaves four edges:
343
338
  *
@@ -361,81 +356,55 @@ interface ActionLoggerShape {
361
356
  */
362
357
  readonly group: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
363
358
  /**
364
- * Run an effect under a `▸ <name>` header line, without opening a group.
359
+ * Run an effect under a phase heading: one bold line, never folded.
365
360
  *
366
361
  * @remarks
367
- * The phase-level banner: the same one-line, neutralized header a nested
368
- * {@link ActionLoggerShape.group} writes, then the body, with no
369
- * `::group::` and no change to the depth. So the groups inside it stay
370
- * top level and each renders as its own collapsible section in the runner
371
- * log, which a `group` wrapper cannot give them: the runner does not nest
372
- * groups, and a wrapper that opened one would swallow every inner group
373
- * into a header line. Reach for this when a phase encloses groups, and for
374
- * `group` when it encloses only lines.
375
- *
376
- * The header goes out through `Console`, like a group command, so it is
377
- * never captured into, or discarded with, an enclosing `withBuffer` or
378
- * `withStep` transcript. Nothing is written when the body ends, and a
379
- * failure flushes no buffer here: the groups inside do that for their own
380
- * sections. Called inside an open group it is simply a header line in that
381
- * group. The test doubles pass the body through unchanged.
362
+ * What a reader scans for. Nothing is written when the phase ends, and the group depth is unchanged, so the steps
363
+ * inside it fold as top-level steps. Inside a step the heading is a line of that step's detail.
382
364
  */
383
- readonly heading: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
365
+ readonly phase: <A, E, R>(title: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
384
366
  /**
385
- * Run an effect with its verbose output captured and replayed on exit.
367
+ * Run an effect as a step: its detail held, one result line when it ends.
386
368
  *
387
369
  * @remarks
388
- * Warnings and errors are **not** buffered — they go out as they happen, so a
389
- * long step still reports trouble while it is running. Everything at `Info`
390
- * and below is held and flushed on every exit path, including a defect or an
391
- * interruption, so a clean run still prints its transcript. A step that
392
- * should be **quiet** when it succeeds passes
393
- * `{ onSuccess: "discard" }` ({@link WithBufferOptions}); failure still
394
- * spills the transcript either way.
370
+ * The detail is every log line below `Warn`, `Debug` and `Trace` included whatever the ambient minimum level, every
371
+ * line a nested {@link ActionLoggerShape.group} or step writes, and every line written straight to `Console`'s
372
+ * `log`, `info`, `debug`, `trace`, `warn`, `error` or `dirxml` inside the step (`@effected/cli-kit`'s renderers, a
373
+ * raw `Console.log`). `Console.table`, `dir`, `count`, the `time*` and the `group*` members are not captured: they
374
+ * print through at once. A workflow command written to `Console` is not
375
+ * detail: it goes out at once, so an `::add-mask::` reaches the runner before the secret can appear in any line,
376
+ * except a group command, which becomes a `▸ <title>` header line. Warnings and errors are never held: they go out
377
+ * as annotations the moment they happen, and the result line counts them.
395
378
  *
396
- * Buffering is skipped entirely when the runner has step debugging enabled or
397
- * the ambient minimum log level is already `Debug` or lower — someone asking
398
- * for verbose output wants it live, and that overrides
399
- * `onSuccess: "discard"` too: asking for debug output means wanting to see
400
- * what a green step did. Under `Action.run` the two conditions coincide,
401
- * because step debugging is what lowers the ambient level to `Debug`; the
402
- * step-debug check still stands on its own for a program that opted out
403
- * with `stepDebugLogLevel: false` or runs outside `Action.run`.
404
- */
405
- readonly withBuffer: <A, E, R>(label: string, effect: Effect.Effect<A, E, R>, options?: WithBufferOptions) => Effect.Effect<A, E, R>;
406
- /**
407
- * Run a named step: quiet when it succeeds, its full transcript when it does
408
- * not.
409
- *
410
- * @remarks
411
- * The composition a release log actually wants, and the one
412
- * {@link ActionLoggerShape.withBuffer} alone does not reach. Buffering with
413
- * `{ onSuccess: "discard" }` gets a green step to *zero* lines; this trades
414
- * that transcript for exactly one:
379
+ * The step's window ({@link StepOptions.window}, 30 seconds by default) is how long the detail is held. A step that
380
+ * runs past it goes live: it writes `… <name> is taking longer than <window>, showing live output`, everything held
381
+ * so far, then each detail line as it happens, indented, and finally its result line, unfolded, with the same marks.
382
+ * A window of zero streams from the start, with the opening line `… <name>`; runner debug (`RUNNER_DEBUG=1`) or an
383
+ * ambient minimum log level of `Debug` or lower makes every window zero. Only the outermost open step has a window:
384
+ * an inner step's own is ignored, and when the outer step is live the inner result lines print as they finish.
385
+ * While two or more steps stream at once, each live detail line is prefixed `[<name>] ` with its outermost step's
386
+ * name.
415
387
  *
416
- * 1. verbose output is captured rather than printed live,
417
- * 2. on success the transcript is dropped and a single info line — `summary`,
418
- * default `✅ <name>` ({@link WithStepOptions}) — goes out in its place,
419
- * 3. on failure a `❌ <name>` header lands **first**, then the transcript
420
- * spills beneath it.
388
+ * The result line is `<mark> <summary or name> · <duration>`, the mark `✓` for a success, `⚠` for a success that
389
+ * logged a warning or an error, or in which a nested step failed and was recovered from (here or in any step
390
+ * inside it, each counted on the line), and `✗` for a failure ({@link StepOptions}):
421
391
  *
422
- * The ordering in (3) is a property of the **buffered** path. With step
423
- * debugging on, nothing is buffered — verbose output has already gone out
424
- * live by the time the failure fires — so the header lands *after* the
425
- * transcript it would otherwise introduce. That is the honest trade of
426
- * asking for live output, not a defect, and both orderings are pinned by
427
- * test.
392
+ * 1. a success with detail is one folded `::group::` titled by the result line, the detail inside it, unless a
393
+ * nested step failed, which is never folded away;
394
+ * 2. a success without detail is the result line alone;
395
+ * 3. a failure is never folded: the result line, then the detail indented beneath it, then the failure itself
396
+ * propagates unchanged. An interruption is written the same way, as `✗ <name> · interrupted`.
428
397
  *
429
- * The header and the summary are the whole difference from `withBuffer`, and
430
- * they are why this is a member rather than a documented recipe: `group` +
431
- * `withBuffer` looks like complete parity until you notice nothing emits the
432
- * success line.
398
+ * A step inside a step opens no group: its result line, and its detail indented above it, are lines of the
399
+ * enclosing step's detail. Inside the step the group depth is at least 1, so `group` and `@effected/cli-kit`'s
400
+ * renderers write plain lines rather than a group the runner cannot nest. A step opened inside a `group` cannot fold
401
+ * either, and writes its result line with the detail indented beneath it.
433
402
  *
434
- * The summary survives step debugging. Buffering is skipped when the runner
435
- * asks for verbose output, but the line naming what succeeded is still the
436
- * cheapest thing in the log.
403
+ * Every line passes through `CommandNeutralizer.text`, so no detail line can be a workflow command. A fiber forked
404
+ * inside a step that logs after the step has ended is not dropped: its lines print as ordinary log lines, unindented
405
+ * and unprefixed, and a step it opens is a new outermost step.
437
406
  */
438
- readonly withStep: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>, options?: WithStepOptions) => Effect.Effect<A, E, R>;
407
+ readonly step: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>, options?: StepOptions<A>) => Effect.Effect<A, E, R>;
439
408
  /**
440
409
  * Emit a `::notice::` annotation.
441
410
  *
@@ -454,9 +423,29 @@ interface ActionLoggerShape {
454
423
  */
455
424
  readonly annotated: <A, E, R>(properties: AnnotationProperties$1, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
456
425
  }
426
+ /**
427
+ * One entry of the log {@link ActionLogger.recording} captured: a phase heading, or a step with its detail, outcome and
428
+ * the steps and phases opened inside it.
429
+ *
430
+ * @public
431
+ */
432
+ type StepLogEntry = {
433
+ readonly kind: "phase";
434
+ readonly title: string;
435
+ } | {
436
+ readonly kind: "step";
437
+ readonly name: string;
438
+ /** `"warning"` is a success that logged a warning or an error, or in which a nested step failed. */
439
+ readonly outcome: "success" | "warning" | "failure" | "interrupted";
440
+ /** The result line's text, without its mark, counts or duration. */
441
+ readonly summary: string;
442
+ /** The lines logged below `Warn` inside the step, not those of nested steps. */
443
+ readonly detail: ReadonlyArray<string>;
444
+ readonly steps: ReadonlyArray<StepLogEntry>;
445
+ };
457
446
  declare const ActionLogger_base: Context.ServiceClass<ActionLogger, "@effected/github-actions/ActionLogger", ActionLoggerShape>;
458
447
  /**
459
- * Groups, buffered step transcripts, notices — and the `Logger` that renders
448
+ * Groups, phases, steps, notices — and the `Logger` that renders
460
449
  * every `Effect.log*` in the kit as a workflow command.
461
450
  *
462
451
  * @remarks
@@ -472,7 +461,7 @@ declare const ActionLogger_base: Context.ServiceClass<ActionLogger, "@effected/g
472
461
  *
473
462
  * const program = Effect.gen(function* () {
474
463
  * const logger = yield* ActionLogger;
475
- * yield* logger.group("install", logger.withBuffer("pnpm", Effect.logInfo("resolving")));
464
+ * yield* logger.phase("Install", logger.step("pnpm", Effect.logInfo("resolving")));
476
465
  * });
477
466
  * ```
478
467
  *
@@ -480,7 +469,7 @@ declare const ActionLogger_base: Context.ServiceClass<ActionLogger, "@effected/g
480
469
  */
481
470
  export declare class ActionLogger extends ActionLogger_base {
482
471
  /**
483
- * The service: groups, the buffered step renderer, notices and annotations.
472
+ * The service: groups, phases, steps, notices and annotations.
484
473
  *
485
474
  * @remarks
486
475
  * This installs no `Logger`. Without {@link ActionLogger.layerLogger} (or `Action.run`, which installs it) Effect's
@@ -515,11 +504,51 @@ export declare class ActionLogger extends ActionLogger_base {
515
504
  * **A recorded exception to the die-on-unstubbed rule**, alongside
516
505
  * {@link ActionEnvironment.makeTest}. A logger that dies when a suite logs
517
506
  * would make every double unusable, and silence is the honest default for a
518
- * service whose whole job is output. Group, heading and buffer wrappers pass their
519
- * effect through unchanged, so the double does not model group nesting:
520
- * a test of nested-group output needs the live {@link ActionLogger.layer}.
507
+ * service whose whole job is output. Group, phase and step wrappers pass their
508
+ * effect through unchanged, so the double does not model group nesting or
509
+ * the step log: a test of that output needs the live {@link ActionLogger.layer}
510
+ * or {@link ActionLogger.recording}.
521
511
  */
522
512
  static readonly makeTest: (overrides?: Partial<ActionLoggerShape>) => ActionLoggerShape;
513
+ /**
514
+ * A double that records the step log's structure so a test can assert it.
515
+ *
516
+ * @remarks
517
+ * `entries()` returns the phases and steps opened so far, each step with its detail (every line below `Warn`),
518
+ * outcome, result text and nested steps. The step log itself writes nothing to the console. A raw `Console` write
519
+ * inside a recorded step is not detail and still prints, so test `Console` or `@effected/cli-kit` output against
520
+ * the live layer with `TestConsole`. The other members behave as in {@link ActionLogger.makeTest}.
521
+ */
522
+ static readonly recording: () => {
523
+ readonly layer: Layer.Layer<ActionLogger>;
524
+ readonly entries: () => ReadonlyArray<StepLogEntry>;
525
+ };
526
+ /**
527
+ * Run a child process, writing its command line, its output and its exit code as the current step's detail.
528
+ *
529
+ * @remarks
530
+ * Writes `$ <display>` (the command line, secrets redacted, unless `display` is given), then each stdout and stderr
531
+ * line as it arrives, then `exit <code>`. Both streams are read concurrently, so a child that fills one pipe cannot
532
+ * deadlock the other. Every line is detail, so the step's held, live and prefix rules apply; stderr lines are
533
+ * detail too, not warnings. Outside any step the lines print live. Resolves with the exit code, whatever it is, and
534
+ * the collected stdout.
535
+ *
536
+ * Reading stops 10 seconds after the child exits, as `@actions/exec` does: a background grandchild that inherited
537
+ * the child's stdout or stderr would otherwise hold the pipe open, and the call with it, for as long as it lives.
538
+ * What it wrote after that is not read.
539
+ *
540
+ * Stdout is decoded as UTF-8 text and logged line by line, so this suits a child whose stdout is text; a binary
541
+ * stdout needs the raw `ChildProcessSpawner` handle.
542
+ *
543
+ * Fails with `PlatformError` when the spawn fails, or when reading the child's output or its exit status fails after
544
+ * it started. A non-zero exit is never an error.
545
+ */
546
+ static readonly command: (command: ChildProcess.Command, options?: {
547
+ readonly display?: string;
548
+ }) => Effect.Effect<{
549
+ readonly exitCode: number;
550
+ readonly stdout: string;
551
+ }, PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner>;
523
552
  /** {@link ActionLogger.makeTest} behind `Layer.succeed`. */
524
553
  static readonly layerTest: (overrides?: Partial<ActionLoggerShape>) => Layer.Layer<ActionLogger>;
525
554
  /**
@@ -1041,8 +1070,8 @@ export declare const describeCause: (cause: Cause.Cause<unknown>) => string;
1041
1070
  *
1042
1071
  * - **It does not wrap the program in a log buffer.** A buffer that swallowed
1043
1072
  * the transcript on an unhandled defect would leave a run that failed and
1044
- * printed nothing. `ActionLogger.withBuffer` is opt-in and flushes on every
1045
- * exit path including a defect, so the buffering is where the caller can
1073
+ * printed nothing. `ActionLogger.step` is opt-in and writes its result line on
1074
+ * every exit path including a defect, so the holding is where the caller can
1046
1075
  * see it.
1047
1076
  * - **It does not throw.** The returned promise always resolves; the failure is
1048
1077
  * in `process.exitCode`, which is what the runner reads. An action entry
@@ -3723,6 +3752,443 @@ export declare class CheckDocument extends CheckDocument_base {
3723
3752
  /** {@link CheckDocument.makeTest} behind a `Layer`. */
3724
3753
  static readonly layerTest: (overrides?: Partial<CheckDocumentShape>) => Layer.Layer<CheckDocument>;
3725
3754
  }
3755
+ /**
3756
+ * What to check out: a tagged union naming the ref the working tree lands on.
3757
+ *
3758
+ * @remarks
3759
+ * `Event` is the workflow's own `GITHUB_REF` at `GITHUB_SHA`; `Default` is the
3760
+ * repository's default branch. `Ref` takes a raw ref exactly as the `ref` input
3761
+ * of the stock checkout action does. Every member that names something movable
3762
+ * may pin it with `commit`.
3763
+ *
3764
+ * @public
3765
+ */
3766
+ export declare const CheckoutRef: Schema.TaggedUnion<{
3767
+ readonly Branch: Schema.TaggedStruct<"Branch", {
3768
+ readonly name: Schema.String;
3769
+ readonly commit: Schema.optionalKey<Schema.String>;
3770
+ }>;
3771
+ readonly Commit: Schema.TaggedStruct<"Commit", {
3772
+ readonly sha: Schema.String;
3773
+ }>;
3774
+ readonly Default: Schema.TaggedStruct<"Default", {}>;
3775
+ readonly Event: Schema.TaggedStruct<"Event", {}>;
3776
+ readonly PullRequest: Schema.TaggedStruct<"PullRequest", {
3777
+ readonly number: Schema.Number;
3778
+ readonly kind: Schema.Literals<readonly ["merge", "head"]>;
3779
+ readonly commit: Schema.optionalKey<Schema.String>;
3780
+ }>;
3781
+ readonly Ref: Schema.TaggedStruct<"Ref", {
3782
+ readonly ref: Schema.String;
3783
+ readonly commit: Schema.optionalKey<Schema.String>;
3784
+ }>;
3785
+ readonly Tag: Schema.TaggedStruct<"Tag", {
3786
+ readonly name: Schema.String;
3787
+ readonly commit: Schema.optionalKey<Schema.String>;
3788
+ }>;
3789
+ }>;
3790
+ /**
3791
+ * The ref a checkout lands on.
3792
+ *
3793
+ * @public
3794
+ */
3795
+ export type CheckoutRef = typeof CheckoutRef.Type;
3796
+ /**
3797
+ * How a checkout authenticates: a token, or an SSH key.
3798
+ *
3799
+ * @remarks
3800
+ * `Ssh` defaults `strict` to `true` and `user` to `"git"`. Its optional `token`
3801
+ * still serves the API calls, as the stock checkout's does. Every secret is a
3802
+ * `Redacted<string>`.
3803
+ *
3804
+ * @public
3805
+ */
3806
+ export declare const CheckoutAuth: Schema.TaggedUnion<{
3807
+ readonly Ssh: Schema.TaggedStruct<"Ssh", {
3808
+ readonly key: Schema.Redacted<Schema.String>;
3809
+ readonly knownHosts: Schema.optionalKey<Schema.String>;
3810
+ readonly strict: Schema.optionalKey<Schema.Boolean>;
3811
+ readonly user: Schema.optionalKey<Schema.String>;
3812
+ readonly token: Schema.optionalKey<Schema.Redacted<Schema.String>>;
3813
+ }>;
3814
+ readonly Token: Schema.TaggedStruct<"Token", {
3815
+ readonly token: Schema.Redacted<Schema.String>;
3816
+ }>;
3817
+ }>;
3818
+ /**
3819
+ * How a checkout authenticates.
3820
+ *
3821
+ * @public
3822
+ */
3823
+ export type CheckoutAuth = typeof CheckoutAuth.Type;
3824
+ /**
3825
+ * Everything {@link Checkout.checkout} accepts.
3826
+ *
3827
+ * @remarks
3828
+ * Defaults: `ref` is `Event` when `repository` is the workflow's own
3829
+ * (case-insensitive), else `Default`; `path` `"."`; `credentials` `"job"`;
3830
+ * `clean` true; `depth` 1; `fetchTags` false; `sparse.cone` true; `lfs` false;
3831
+ * `submodules` false; `safeDirectory` true; `serverUrl` the runner's
3832
+ * `GITHUB_SERVER_URL` or `https://github.com` (an empty one counts as omitted);
3833
+ * `stateKey` `"effected-checkout"`.
3834
+ *
3835
+ * @public
3836
+ */
3837
+ interface CheckoutOptions {
3838
+ /** The repository to check out; the workflow's own when omitted. */
3839
+ readonly repository?: {
3840
+ readonly owner: string;
3841
+ readonly name: string;
3842
+ };
3843
+ /** What to check out. */
3844
+ readonly ref?: CheckoutRef;
3845
+ /** The directory to check out into, relative to the workspace. */
3846
+ readonly path?: string;
3847
+ /** How to authenticate. */
3848
+ readonly auth: CheckoutAuth;
3849
+ /**
3850
+ * Where the credential lives afterwards: for the job, for the action's own run, or nowhere. Under `"job"` and
3851
+ * `"action"` both the token (through `includeIf`) and an SSH key's `core.sshCommand` are persisted in the
3852
+ * repository and its submodules, so later git authenticates either way; `"action"` removes them when the scope
3853
+ * closes.
3854
+ */
3855
+ readonly credentials?: "job" | "action" | "none";
3856
+ /** Whether to clean the target directory first. */
3857
+ readonly clean?: boolean;
3858
+ /** The fetch depth, or `"full"` for all history. */
3859
+ readonly depth?: number | "full";
3860
+ /** Whether to fetch tags. */
3861
+ readonly fetchTags?: boolean;
3862
+ /** A partial-clone filter, such as `blob:none`. */
3863
+ readonly filter?: string;
3864
+ /** A sparse checkout. */
3865
+ readonly sparse?: {
3866
+ readonly patterns: ReadonlyArray<string>;
3867
+ readonly cone?: boolean;
3868
+ };
3869
+ /** Whether to fetch Git LFS objects. */
3870
+ readonly lfs?: boolean;
3871
+ /** Whether to check out submodules, and whether recursively. */
3872
+ readonly submodules?: boolean | "recursive";
3873
+ /** Whether to mark the checkout a git `safe.directory`. */
3874
+ readonly safeDirectory?: boolean;
3875
+ /**
3876
+ * The GitHub server URL: an absolute `http` or `https` URL, such as `https://ghe.example.com`. One without a scheme
3877
+ * fails {@link CheckoutServerUrlError}.
3878
+ */
3879
+ readonly serverUrl?: string;
3880
+ /**
3881
+ * The remote URL to use instead of one derived from `serverUrl` and `repository`. With it set, the default branch
3882
+ * is the remote's own `HEAD`, not the API's answer for `repository`.
3883
+ */
3884
+ readonly remoteUrl?: string;
3885
+ /** Permits checking out fork pull request code from a privileged event. */
3886
+ readonly allowUnsafePrCheckout?: boolean;
3887
+ /**
3888
+ * The state key the cleanup phase reads back. The runner keeps one value per key, so give each `"job"` checkout
3889
+ * of a different path its own key, and call `Checkout.cleanup({ stateKey })` for each; a second one under a key
3890
+ * already in use fails `CheckoutStateKeyInUseError` before it writes anything.
3891
+ */
3892
+ readonly stateKey?: string;
3893
+ }
3894
+ declare const CheckoutResult_base: Schema.Class<CheckoutResult, Schema.Struct<{
3895
+ /** The resolved ref, or `""` for a bare commit. */
3896
+ readonly ref: Schema.String;
3897
+ /** The commit now checked out. */
3898
+ readonly commit: Schema.String;
3899
+ /** The directory checked out into. */
3900
+ readonly path: Schema.String;
3901
+ /** The repository checked out. */
3902
+ readonly repository: Schema.Struct<{
3903
+ readonly owner: Schema.String;
3904
+ readonly name: Schema.String;
3905
+ }>;
3906
+ }>, {}>;
3907
+ /**
3908
+ * What a checkout resolved to.
3909
+ *
3910
+ * @remarks
3911
+ * `ref` is the resolved ref, as the `ref` output of the stock checkout action
3912
+ * is: `""` for a bare commit.
3913
+ *
3914
+ * @public
3915
+ */
3916
+ export declare class CheckoutResult extends CheckoutResult_base {}
3917
+ declare const CheckoutGitTooOldError_base: Schema.Class<CheckoutGitTooOldError, Schema.TaggedStruct<"CheckoutGitTooOldError", {
3918
+ /** The git version found. */
3919
+ readonly found: Schema.String;
3920
+ /** The oldest git version supported. */
3921
+ readonly required: Schema.String;
3922
+ }>, import("effect/Cause").YieldableError>;
3923
+ /**
3924
+ * Raised when the runner's git is older than the floor.
3925
+ *
3926
+ * @public
3927
+ */
3928
+ export declare class CheckoutGitTooOldError extends CheckoutGitTooOldError_base {
3929
+ get message(): string;
3930
+ }
3931
+ declare const CheckoutUnsafePullRequestError_base: Schema.Class<CheckoutUnsafePullRequestError, Schema.TaggedStruct<"CheckoutUnsafePullRequestError", {
3932
+ /** The triggering event, such as `pull_request_target`. */
3933
+ readonly event: Schema.String;
3934
+ /** The repository being checked out. */
3935
+ readonly repository: Schema.String;
3936
+ /** The ref being checked out. */
3937
+ readonly ref: Schema.String;
3938
+ }>, import("effect/Cause").YieldableError>;
3939
+ /**
3940
+ * Raised when a privileged event would check out fork pull request code.
3941
+ *
3942
+ * @public
3943
+ */
3944
+ export declare class CheckoutUnsafePullRequestError extends CheckoutUnsafePullRequestError_base {
3945
+ get message(): string;
3946
+ }
3947
+ declare const CheckoutRefNotFoundError_base: Schema.Class<CheckoutRefNotFoundError, Schema.TaggedStruct<"CheckoutRefNotFoundError", {
3948
+ /** The ref that was not found, after default-branch resolution. */
3949
+ readonly ref: Schema.String;
3950
+ }>, import("effect/Cause").YieldableError>;
3951
+ /**
3952
+ * Raised when the requested ref does not exist on the remote.
3953
+ *
3954
+ * @remarks
3955
+ * For a `Default` checkout `ref` is the default branch it resolved to, such as
3956
+ * `refs/heads/main`, never `""`.
3957
+ *
3958
+ * @public
3959
+ */
3960
+ export declare class CheckoutRefNotFoundError extends CheckoutRefNotFoundError_base {
3961
+ get message(): string;
3962
+ }
3963
+ declare const CheckoutCommitMismatchError_base: Schema.Class<CheckoutCommitMismatchError, Schema.TaggedStruct<"CheckoutCommitMismatchError", {
3964
+ /** The ref that was fetched, after default-branch resolution. */
3965
+ readonly ref: Schema.String;
3966
+ /** The commit the caller pinned. */
3967
+ readonly expected: Schema.String;
3968
+ }>, import("effect/Cause").YieldableError>;
3969
+ /**
3970
+ * Raised when a ref resolved to a different commit than the one pinned.
3971
+ *
3972
+ * @public
3973
+ */
3974
+ export declare class CheckoutCommitMismatchError extends CheckoutCommitMismatchError_base {
3975
+ get message(): string;
3976
+ }
3977
+ declare const CheckoutAuthError_base: Schema.Class<CheckoutAuthError, Schema.TaggedStruct<"CheckoutAuthError", {
3978
+ /** The repository being accessed. */
3979
+ readonly repository: Schema.String;
3980
+ /** What went wrong, with no secret in it. */
3981
+ readonly detail: Schema.String;
3982
+ }>, import("effect/Cause").YieldableError>;
3983
+ /**
3984
+ * Raised when the credentials were refused.
3985
+ *
3986
+ * @public
3987
+ */
3988
+ export declare class CheckoutAuthError extends CheckoutAuthError_base {
3989
+ get message(): string;
3990
+ }
3991
+ declare const CheckoutPathError_base: Schema.Class<CheckoutPathError, Schema.TaggedStruct<"CheckoutPathError", {
3992
+ /** The path requested. */
3993
+ readonly path: Schema.String;
3994
+ /** The workspace it must stay within. */
3995
+ readonly workspace: Schema.String;
3996
+ }>, import("effect/Cause").YieldableError>;
3997
+ /**
3998
+ * Raised when the target path escapes the workspace.
3999
+ *
4000
+ * @public
4001
+ */
4002
+ export declare class CheckoutPathError extends CheckoutPathError_base {
4003
+ get message(): string;
4004
+ }
4005
+ declare const CheckoutDefaultBranchError_base: Schema.Class<CheckoutDefaultBranchError, Schema.TaggedStruct<"CheckoutDefaultBranchError", {
4006
+ /** The repository whose default branch is unknown. */
4007
+ readonly repository: Schema.String;
4008
+ /** Why: the API's or `ls-remote`'s failure, with no secret in it. */
4009
+ readonly detail: Schema.String;
4010
+ }>, import("effect/Cause").YieldableError>;
4011
+ /**
4012
+ * Raised when the repository's default branch could not be determined.
4013
+ *
4014
+ * @public
4015
+ */
4016
+ export declare class CheckoutDefaultBranchError extends CheckoutDefaultBranchError_base {
4017
+ get message(): string;
4018
+ }
4019
+ declare const CheckoutUnqualifiedRefPinError_base: Schema.Class<CheckoutUnqualifiedRefPinError, Schema.TaggedStruct<"CheckoutUnqualifiedRefPinError", {
4020
+ /** The unqualified ref that was pinned. */
4021
+ readonly ref: Schema.String;
4022
+ }>, import("effect/Cause").YieldableError>;
4023
+ /**
4024
+ * Raised when a `Ref` that is not fully qualified is pinned with `commit`.
4025
+ *
4026
+ * @remarks
4027
+ * An unqualified ref pinned to a commit fetches only the commit, and nothing
4028
+ * then names the branch or tag to land on. Pin a branch or tag with `Branch`
4029
+ * or `Tag`, or give `Ref` a full `refs/...` name.
4030
+ *
4031
+ * @public
4032
+ */
4033
+ export declare class CheckoutUnqualifiedRefPinError extends CheckoutUnqualifiedRefPinError_base {
4034
+ get message(): string;
4035
+ }
4036
+ declare const CheckoutStateKeyInUseError_base: Schema.Class<CheckoutStateKeyInUseError, Schema.TaggedStruct<"CheckoutStateKeyInUseError", {
4037
+ /** The state key already in use. */
4038
+ readonly stateKey: Schema.String;
4039
+ /** The path whose credentials it already records. */
4040
+ readonly path: Schema.String;
4041
+ }>, import("effect/Cause").YieldableError>;
4042
+ /**
4043
+ * Raised when a second `"job"` checkout in one action saves its credentials
4044
+ * under a state key another checkout of a different path already used.
4045
+ *
4046
+ * @remarks
4047
+ * The runner keeps one value per state key, so the post entry's
4048
+ * {@link Checkout.cleanup} would find only the later record and leave the
4049
+ * earlier checkout's credentials behind. Give each `"job"` checkout its own
4050
+ * `stateKey` and call `Checkout.cleanup({ stateKey })` for each.
4051
+ *
4052
+ * @public
4053
+ */
4054
+ export declare class CheckoutStateKeyInUseError extends CheckoutStateKeyInUseError_base {
4055
+ get message(): string;
4056
+ }
4057
+ declare const CheckoutServerUrlError_base: Schema.Class<CheckoutServerUrlError, Schema.TaggedStruct<"CheckoutServerUrlError", {
4058
+ /** The server URL as given. */
4059
+ readonly serverUrl: Schema.String;
4060
+ /** Why it was refused. */
4061
+ readonly detail: Schema.String;
4062
+ }>, import("effect/Cause").YieldableError>;
4063
+ /**
4064
+ * Raised when the GitHub server URL is not an absolute `http` or `https` URL.
4065
+ *
4066
+ * @remarks
4067
+ * Checked once, before any git runs, for `serverUrl`, the `github-server-url`
4068
+ * input {@link Checkout.fromInputs} reads, and the runner's `GITHUB_SERVER_URL`.
4069
+ * A host with no scheme, such as `ghe.example.com`, is refused rather than
4070
+ * given `https://`, as the stock checkout action refuses it.
4071
+ *
4072
+ * @public
4073
+ */
4074
+ export declare class CheckoutServerUrlError extends CheckoutServerUrlError_base {
4075
+ get message(): string;
4076
+ }
4077
+ /**
4078
+ * Anything that can go wrong checking out a repository.
4079
+ *
4080
+ * @remarks
4081
+ * One class per failure, so each member carries exactly the fields its own
4082
+ * message needs and `Effect.catchTag` recovers from one without catching the
4083
+ * others.
4084
+ *
4085
+ * @public
4086
+ */
4087
+ type CheckoutError = CheckoutGitTooOldError | CheckoutUnsafePullRequestError | CheckoutRefNotFoundError | CheckoutCommitMismatchError | CheckoutAuthError | CheckoutPathError | CheckoutDefaultBranchError | CheckoutUnqualifiedRefPinError | CheckoutStateKeyInUseError | CheckoutServerUrlError;
4088
+ /**
4089
+ * Checks a repository out the way the stock checkout action does, on `@effected/git`.
4090
+ *
4091
+ * @public
4092
+ */
4093
+ export declare class Checkout {
4094
+ /**
4095
+ * Checks a repository out, in the stock checkout action's order: version
4096
+ * check, unsafe pull request guard, directory preparation, `init`, auth,
4097
+ * default branch, one fetch, ref verification, LFS, sparse set, checkout,
4098
+ * submodules.
4099
+ *
4100
+ * @remarks
4101
+ * Requires git 2.39.0 or later and fails {@link CheckoutGitTooOldError}
4102
+ * before any other git runs. Every secret is masked first.
4103
+ *
4104
+ * An existing repository of the same remote is reused (lock files removed,
4105
+ * `HEAD` detached, local and conflicting remote-tracking branches deleted,
4106
+ * and with `clean` a `clean -ffdx` and `reset --hard HEAD`); any other
4107
+ * directory has its contents deleted. The fetch, the default branch lookup
4108
+ * and the LFS fetch are retried, as the stock action retries them. Every git
4109
+ * step runs under a 30 minute ceiling: a checkout after a partial-clone
4110
+ * fetch, an LFS smudge or a clean of a big tree can take as long as a fetch.
4111
+ *
4112
+ * The credentials' lifetime is `options.credentials`: `"job"` saves what
4113
+ * was written under `stateKey` before any fetch, for {@link Checkout.cleanup}
4114
+ * in the post step, refusing a second `"job"` checkout of another path
4115
+ * under a key already in use; `"action"` removes it when the enclosing `Scope`
4116
+ * closes, on success, failure or interruption; `"none"` removes it before
4117
+ * this returns. The temporary global config holding `safe.directory` is
4118
+ * discarded when this returns, whatever the lifetime.
4119
+ *
4120
+ * The log is one phase, `Checkout <owner>/<name> @ <ref>`, with one step
4121
+ * per phase of work; each step's detail is the git transcript. The
4122
+ * repository's object format and default branch come from the GitHub API
4123
+ * (the default branch from the remote's `HEAD` instead for an SSH key or a
4124
+ * `remoteUrl`), as the stock action asks it: through a client built from the checkout's
4125
+ * own token against its own server's API base (`<origin>/api/v3` for a GitHub
4126
+ * Enterprise Server `serverUrl`). An ambient `GitHubClient` is used only when
4127
+ * the checkout has no token, an `Ssh` auth without one. A failed default
4128
+ * branch lookup is {@link CheckoutDefaultBranchError}, its `detail` the reason.
4129
+ */
4130
+ static readonly checkout: (options: CheckoutOptions) => Effect.Effect<CheckoutResult, CheckoutError | GitCommandError | NotARepositoryError | UnknownRefError | ActionStateError | ActionEnvironmentError | PlatformError.PlatformError, Scope.Scope | Git | FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner | SecureRandom.SecureRandom | ActionEnvironment | ActionOutputs | ActionState | ActionLogger>;
4131
+ /**
4132
+ * Runs the post-step cleanup of a `"job"` checkout: reads the record saved
4133
+ * under `stateKey` and removes everything the checkout wrote.
4134
+ *
4135
+ * @remarks
4136
+ * No saved record is a no-op. Removal covers the credentials file, the SSH
4137
+ * files, `includeIf`, the extraheader, `core.sshCommand` and the submodules'
4138
+ * `insteadOf`, with `safe.directory` handled for the repository as the stock
4139
+ * post step does. It never fails: every failure, an unreadable record
4140
+ * included, becomes a warning, so a post step cannot turn a green job red.
4141
+ * It is uninterruptible, so a cancelled job cannot leave credentials behind.
4142
+ */
4143
+ static readonly cleanup: (options?: {
4144
+ readonly stateKey?: string;
4145
+ }) => Effect.Effect<void, never, Git | FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner | SecureRandom.SecureRandom | ActionEnvironment | ActionState | ActionLogger>;
4146
+ /**
4147
+ * Reads {@link CheckoutOptions} from the action's inputs, on the stock
4148
+ * checkout action's input surface, so an action can expose a
4149
+ * checkout-compatible interface unchanged.
4150
+ *
4151
+ * @remarks
4152
+ * Reads `repository`, `ref`, `token`, `ssh-key`, `ssh-known-hosts`,
4153
+ * `ssh-strict`, `ssh-user`, `persist-credentials`, `path`, `clean`, `filter`,
4154
+ * `sparse-checkout`, `sparse-checkout-cone-mode`, `fetch-depth`,
4155
+ * `fetch-tags`, `show-progress` (read and ignored), `lfs`, `submodules`,
4156
+ * `set-safe-directory`, `github-server-url` and `allow-unsafe-pr-checkout`,
4157
+ * each as `<prefix><name>` when a prefix is given. `token` is required; a
4158
+ * present `ssh-key` makes the auth `Ssh`, carrying the token for the API
4159
+ * calls.
4160
+ *
4161
+ * `persist-credentials` true is `"job"` and false `"none"`; `fetch-depth` at
4162
+ * or below zero, or not a number, is `"full"`; `submodules` is `recursive`,
4163
+ * `true` or else false. Every boolean reads as the stock action reads it:
4164
+ * true only for a case-insensitive `true`, false for any other value, and
4165
+ * an absent or empty input takes the stock action's in-code default, which
4166
+ * for `persist-credentials` is false, not the manifest's `true` (on a
4167
+ * runner an unsupplied input arrives as the manifest default, so only an
4168
+ * explicit empty value meets the in-code one). `ref` is trimmed of ASCII
4169
+ * whitespace only, so a leading BOM or NBSP survives as part of a `Ref`:
4170
+ * empty is `Event` for the workflow's own repository and `Default`
4171
+ * otherwise, a bare 40 or 64 hex value is a `Commit`, anything else a `Ref`.
4172
+ *
4173
+ * The `path` is not validated here; {@link Checkout.checkout} refuses one
4174
+ * that leaves the workspace.
4175
+ */
4176
+ static readonly fromInputs: (options?: {
4177
+ readonly prefix?: string;
4178
+ }) => Effect.Effect<CheckoutOptions, Config.ConfigError | ActionEnvironmentError, ActionEnvironment>;
4179
+ /**
4180
+ * Declares the action inputs {@link Checkout.fromInputs} reads, with the
4181
+ * stock checkout action's descriptions and defaults, for an author to merge
4182
+ * into `action.yml`.
4183
+ */
4184
+ static readonly inputs: (options?: {
4185
+ readonly prefix?: string;
4186
+ }) => Readonly<Record<string, ActionManifestInput>>;
4187
+ /** Publishes a {@link CheckoutResult}'s `ref` and `commit` as step outputs. */
4188
+ static readonly writeOutputs: (result: CheckoutResult, options?: {
4189
+ readonly prefix?: string;
4190
+ }) => Effect.Effect<void, ActionOutputError, ActionOutputs>;
4191
+ }
3726
4192
  /**
3727
4193
  * The kit's check-state vocabulary.
3728
4194
  *
@@ -5765,5 +6231,5 @@ export declare class Secret {
5765
6231
  */
5766
6232
  static readonly adopt: (name: string) => Config.Config<Redacted.Redacted<string>>;
5767
6233
  }
5768
- export { type ActionCacheShape, type ActionEnvironmentShape, type ActionInputRecording, type ActionLoggerShape, type ActionManifestError, type ActionManifestRuns, type ActionManifestUsage, type ActionOutputError, type ActionOutputsShape, type ActionRunOptions, type ActionServices, type ActionStateShape, type AnnotationProperties, type ArtifactItem, type ArtifactRef, type ArtifactShape, type BlobEnvelopeError, type BlobStoreShape, type CacheKeyError, type CheckDocumentOptions, type CheckDocumentShape, type CheckDocumentSink, type CheckFlushOutcome, type CheckRunConclusion, type CheckRunProjection, type ClientLayerOptions, type DataBlobTransfer, type DetachedProcessError, type DetachedProcessOps, type DetachedSpawnOptions, type DownloadOptions, type DownloadResult, type DryRunShape, type ExtractOptions, type FileBlobTransfer, type GitHubHeadingDepth, type GitHubListOptions, type GitHubRowSchema, type GitHubSchemaTable, type GitHubSchemaTableColumn, type GitHubSchemaTableColumns, type GitHubSchemaTableFormatRequiredKeys, type GitHubSchemaTableFormattedColumn, type GitHubSchemaTableOptions, type ManagedDocumentSource, type OidcTokenIssuerShape, type PackageManagerInstallOptions, type PackageManagerInstallerShape, type PairsOptions, type PathPrependEnv, type PathPrependOptions, type ProvisionFileOptions, type ProvisionOptions, type ProvisionedFile, type ReadOptions, type ReadinessOptions, type RecordedOutputMember, type RecordingOidcTokenIssuer, type RecordingOutputs, type S3Config, type StoredBlob, type ToolDownloadOptions, type ToolInstallerShape, type UploadOptions, type UploadResult, type WithBufferOptions, type WithStepOptions, WorkflowCommand };
6234
+ export { type ActionCacheShape, type ActionEnvironmentShape, type ActionInputRecording, type ActionLoggerShape, type ActionManifestError, type ActionManifestRuns, type ActionManifestUsage, type ActionOutputError, type ActionOutputsShape, type ActionRunOptions, type ActionServices, type ActionStateShape, type AnnotationProperties, type ArtifactItem, type ArtifactRef, type ArtifactShape, type BlobEnvelopeError, type BlobStoreShape, type CacheKeyError, type CheckDocumentOptions, type CheckDocumentShape, type CheckDocumentSink, type CheckFlushOutcome, type CheckRunConclusion, type CheckRunProjection, type CheckoutError, type CheckoutOptions, type ClientLayerOptions, type DataBlobTransfer, type DetachedProcessError, type DetachedProcessOps, type DetachedSpawnOptions, type DownloadOptions, type DownloadResult, type DryRunShape, type ExtractOptions, type FileBlobTransfer, type GitHubHeadingDepth, type GitHubListOptions, type GitHubRowSchema, type GitHubSchemaTable, type GitHubSchemaTableColumn, type GitHubSchemaTableColumns, type GitHubSchemaTableFormatRequiredKeys, type GitHubSchemaTableFormattedColumn, type GitHubSchemaTableOptions, type ManagedDocumentSource, type OidcTokenIssuerShape, type PackageManagerInstallOptions, type PackageManagerInstallerShape, type PairsOptions, type PathPrependEnv, type PathPrependOptions, type ProvisionFileOptions, type ProvisionOptions, type ProvisionedFile, type ReadOptions, type ReadinessOptions, type RecordedOutputMember, type RecordingOidcTokenIssuer, type RecordingOutputs, type S3Config, type StepLogEntry, type StepOptions, type StoredBlob, type ToolDownloadOptions, type ToolInstallerShape, type UploadOptions, type UploadResult, WorkflowCommand };
5769
6235
  //# sourceMappingURL=index.d.ts.map