@shopify/cli-kit 0.33.1 → 0.33.5

package/dist/index.d.ts

@@ -1,45 +1,1421 @@
 /// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Readable } from 'stream';
 import { Writable } from 'node:stream';
-import open from 'open';
 import path$1 from 'path';
 import * as fs from 'fs';
-import { EventEmitter } from 'events';
+import { platform } from 'node:process';
 import { RequestOptions } from 'http';
 
+/**
+ * Represents a disposable resource, such as the execution of an Observable. A
+ * Subscription has one important method, `unsubscribe`, that takes no argument
+ * and just disposes the resource held by the subscription.
+ *
+ * Additionally, subscriptions may be grouped together through the `add()`
+ * method, which will attach a child Subscription to the current Subscription.
+ * When a Subscription is unsubscribed, all its children (and its grandchildren)
+ * will be unsubscribed as well.
+ *
+ * @class Subscription
+ */
+declare class Subscription implements SubscriptionLike {
+    private initialTeardown?;
+    /** @nocollapse */
+    static EMPTY: Subscription;
+    /**
+     * A flag to indicate whether this Subscription has already been unsubscribed.
+     */
+    closed: boolean;
+    private _parentage;
+    /**
+     * The list of registered teardowns to execute upon unsubscription. Adding and removing from this
+     * list occurs in the {@link #add} and {@link #remove} methods.
+     */
+    private _teardowns;
+    /**
+     * @param initialTeardown A function executed first as part of the teardown
+     * process that is kicked off when {@link #unsubscribe} is called.
+     */
+    constructor(initialTeardown?: (() => void) | undefined);
+    /**
+     * Disposes the resources held by the subscription. May, for instance, cancel
+     * an ongoing Observable execution or cancel any other type of work that
+     * started when the Subscription was created.
+     * @return {void}
+     */
+    unsubscribe(): void;
+    /**
+     * Adds a teardown to this subscription, so that teardown will be unsubscribed/called
+     * when this subscription is unsubscribed. If this subscription is already {@link #closed},
+     * because it has already been unsubscribed, then whatever teardown is passed to it
+     * will automatically be executed (unless the teardown itself is also a closed subscription).
+     *
+     * Closed Subscriptions cannot be added as teardowns to any subscription. Adding a closed
+     * subscription to a any subscription will result in no operation. (A noop).
+     *
+     * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
+     * operation at all. (A noop).
+     *
+     * `Subscription` instances that are added to this instance will automatically remove themselves
+     * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
+     * will need to be removed manually with {@link #remove}
+     *
+     * @param teardown The teardown logic to add to this subscription.
+     */
+    add(teardown: TeardownLogic): void;
+    /**
+     * Checks to see if a this subscription already has a particular parent.
+     * This will signal that this subscription has already been added to the parent in question.
+     * @param parent the parent to check for
+     */
+    private _hasParent;
+    /**
+     * Adds a parent to this subscription so it can be removed from the parent if it
+     * unsubscribes on it's own.
+     *
+     * NOTE: THIS ASSUMES THAT {@link _hasParent} HAS ALREADY BEEN CHECKED.
+     * @param parent The parent subscription to add
+     */
+    private _addParent;
+    /**
+     * Called on a child when it is removed via {@link #remove}.
+     * @param parent The parent to remove
+     */
+    private _removeParent;
+    /**
+     * Removes a teardown from this subscription that was previously added with the {@link #add} method.
+     *
+     * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
+     * from every other `Subscription` they have been added to. This means that using the `remove` method
+     * is not a common thing and should be used thoughtfully.
+     *
+     * If you add the same teardown instance of a function or an unsubscribable object to a `Subcription` instance
+     * more than once, you will need to call `remove` the same number of times to remove all instances.
+     *
+     * All teardown instances are removed to free up memory upon unsubscription.
+     *
+     * @param teardown The teardown to remove from this subscription
+     */
+    remove(teardown: Exclude<TeardownLogic, void>): void;
+}
+
+/// <reference lib="esnext.asynciterable" />
+
+/**
+ * Note: This will add Symbol.observable globally for all TypeScript users,
+ * however, we are no longer polyfilling Symbol.observable
+ */
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}
+/** OPERATOR INTERFACES */
+interface UnaryFunction<T, R> {
+    (source: T): R;
+}
+interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {
+}
+/** SUBSCRIPTION INTERFACES */
+interface Unsubscribable {
+    unsubscribe(): void;
+}
+declare type TeardownLogic = Subscription | Unsubscribable | (() => void) | void;
+interface SubscriptionLike extends Unsubscribable {
+    unsubscribe(): void;
+    readonly closed: boolean;
+}
+/** OBSERVABLE INTERFACES */
+interface Subscribable<T> {
+    subscribe(observer: Partial<Observer<T>>): Unsubscribable;
+}
+interface Observer<T> {
+    next: (value: T) => void;
+    error: (err: any) => void;
+    complete: () => void;
+}
+
+/**
+ * Implements the {@link Observer} interface and extends the
+ * {@link Subscription} class. While the {@link Observer} is the public API for
+ * consuming the values of an {@link Observable}, all Observers get converted to
+ * a Subscriber, in order to provide Subscription-like capabilities such as
+ * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
+ * implementing operators, but it is rarely used as a public API.
+ *
+ * @class Subscriber<T>
+ */
+declare class Subscriber<T> extends Subscription implements Observer<T> {
+    /**
+     * A static factory for a Subscriber, given a (potentially partial) definition
+     * of an Observer.
+     * @param next The `next` callback of an Observer.
+     * @param error The `error` callback of an
+     * Observer.
+     * @param complete The `complete` callback of an
+     * Observer.
+     * @return A Subscriber wrapping the (partially defined)
+     * Observer represented by the given arguments.
+     * @nocollapse
+     * @deprecated Do not use. Will be removed in v8. There is no replacement for this
+     * method, and there is no reason to be creating instances of `Subscriber` directly.
+     * If you have a specific use case, please file an issue.
+     */
+    static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T>;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    protected isStopped: boolean;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    protected destination: Subscriber<any> | Observer<any>;
+    /**
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     * There is no reason to directly create an instance of Subscriber. This type is exported for typings reasons.
+     */
+    constructor(destination?: Subscriber<any> | Observer<any>);
+    /**
+     * The {@link Observer} callback to receive notifications of type `next` from
+     * the Observable, with a value. The Observable may call this method 0 or more
+     * times.
+     * @param {T} [value] The `next` value.
+     * @return {void}
+     */
+    next(value?: T): void;
+    /**
+     * The {@link Observer} callback to receive notifications of type `error` from
+     * the Observable, with an attached `Error`. Notifies the Observer that
+     * the Observable has experienced an error condition.
+     * @param {any} [err] The `error` exception.
+     * @return {void}
+     */
+    error(err?: any): void;
+    /**
+     * The {@link Observer} callback to receive a valueless notification of type
+     * `complete` from the Observable. Notifies the Observer that the Observable
+     * has finished sending push-based notifications.
+     * @return {void}
+     */
+    complete(): void;
+    unsubscribe(): void;
+    protected _next(value: T): void;
+    protected _error(err: any): void;
+    protected _complete(): void;
+}
+
+/***
+ * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+ */
+interface Operator<T, R> {
+    call(subscriber: Subscriber<R>, source: any): TeardownLogic;
+}
+
+/**
+ * A representation of any set of values over any amount of time. This is the most basic building block
+ * of RxJS.
+ *
+ * @class Observable<T>
+ */
+declare class Observable<T> implements Subscribable<T> {
+    /**
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     */
+    source: Observable<any> | undefined;
+    /**
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     */
+    operator: Operator<any, T> | undefined;
+    /**
+     * @constructor
+     * @param {Function} subscribe the function that is called when the Observable is
+     * initially subscribed to. This function is given a Subscriber, to which new values
+     * can be `next`ed, or an `error` method can be called to raise an error, or
+     * `complete` can be called to notify of a successful completion.
+     */
+    constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
+    /**
+     * Creates a new Observable by calling the Observable constructor
+     * @owner Observable
+     * @method create
+     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
+     * @return {Observable} a new observable
+     * @nocollapse
+     * @deprecated Use `new Observable()` instead. Will be removed in v8.
+     */
+    static create: (...args: any[]) => any;
+    /**
+     * Creates a new Observable, with this Observable instance as the source, and the passed
+     * operator defined as the new observable's operator.
+     * @method lift
+     * @param operator the operator defining the operation to take on the observable
+     * @return a new observable with the Operator applied
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     * If you have implemented an operator using `lift`, it is recommended that you create an
+     * operator by simply returning `new Observable()` directly. See "Creating new operators from
+     * scratch" section here: https://rxjs.dev/guide/operators
+     */
+    lift<R>(operator?: Operator<T, R>): Observable<R>;
+    subscribe(observer?: Partial<Observer<T>>): Subscription;
+    subscribe(next: (value: T) => void): Subscription;
+    /** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
+    subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
+    /**
+     * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
+     * APIs that expect promises, like `async/await`. You cannot unsubscribe from this.
+     *
+     * **WARNING**: Only use this with observables you *know* will complete. If the source
+     * observable does not complete, you will end up with a promise that is hung up, and
+     * potentially all of the state of an async function hanging out in memory. To avoid
+     * this situation, look into adding something like {@link timeout}, {@link take},
+     * {@link takeWhile}, or {@link takeUntil} amongst others.
+     *
+     * ## Example
+     *
+     * ```ts
+     * import { interval, take } from 'rxjs';
+     *
+     * const source$ = interval(1000).pipe(take(4));
+     *
+     * async function getTotal() {
+     *   let total = 0;
+     *
+     *   await source$.forEach(value => {
+     *     total += value;
+     *     console.log('observable -> ' + value);
+     *   });
+     *
+     *   return total;
+     * }
+     *
+     * getTotal().then(
+     *   total => console.log('Total: ' + total)
+     * );
+     *
+     * // Expected:
+     * // 'observable -> 0'
+     * // 'observable -> 1'
+     * // 'observable -> 2'
+     * // 'observable -> 3'
+     * // 'Total: 6'
+     * ```
+     *
+     * @param next a handler for each value emitted by the observable
+     * @return a promise that either resolves on observable completion or
+     *  rejects with the handled error
+     */
+    forEach(next: (value: T) => void): Promise<void>;
+    /**
+     * @param next a handler for each value emitted by the observable
+     * @param promiseCtor a constructor function used to instantiate the Promise
+     * @return a promise that either resolves on observable completion or
+     *  rejects with the handled error
+     * @deprecated Passing a Promise constructor will no longer be available
+     * in upcoming versions of RxJS. This is because it adds weight to the library, for very
+     * little benefit. If you need this functionality, it is recommended that you either
+     * polyfill Promise, or you create an adapter to convert the returned native promise
+     * to whatever promise implementation you wanted. Will be removed in v8.
+     */
+    forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
+    pipe(): Observable<T>;
+    pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
+    pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
+    pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
+    pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
+    pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
+    pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
+    pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
+    pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
+    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
+    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<unknown>;
+    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+    toPromise(): Promise<T | undefined>;
+    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+    toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
+    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+    toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
+}
+
+/**
+ * A Subject is a special type of Observable that allows values to be
+ * multicasted to many Observers. Subjects are like EventEmitters.
+ *
+ * Every Subject is an Observable and an Observer. You can subscribe to a
+ * Subject, and you can call next to feed values as well as error and complete.
+ */
+declare class Subject<T> extends Observable<T> implements SubscriptionLike {
+    closed: boolean;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    observers: Observer<T>[];
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    isStopped: boolean;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    hasError: boolean;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    thrownError: any;
+    /**
+     * Creates a "subject" by basically gluing an observer to an observable.
+     *
+     * @nocollapse
+     * @deprecated Recommended you do not use. Will be removed at some point in the future. Plans for replacement still under discussion.
+     */
+    static create: (...args: any[]) => any;
+    constructor();
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    lift<R>(operator: Operator<T, R>): Observable<R>;
+    next(value: T): void;
+    error(err: any): void;
+    complete(): void;
+    unsubscribe(): void;
+    get observed(): boolean;
+    /**
+     * Creates a new Observable with this Subject as the source. You can do this
+     * to create customize Observer-side logic of the Subject and conceal it from
+     * code that uses the Observable.
+     * @return {Observable} Observable that the Subject casts to
+     */
+    asObservable(): Observable<T>;
+}
+
+interface BasePromptOptions$1 {
+  name: string | (() => string)
+  type: string | (() => string)
+  message: string | (() => string) | (() => Promise<string>)
+  initial?: any
+  required?: boolean
+  format?(value: string): string | Promise<string>
+  result?(value: string): string | Promise<string>
+  skip?: ((state: object) => boolean | Promise<boolean>) | boolean
+  validate?(value: string): boolean | Promise<boolean> | string | Promise<string>
+  onSubmit?(name: string, value: any, prompt: Enquirer.Prompt): boolean | Promise<boolean>
+  onCancel?(name: string, value: any, prompt: Enquirer.Prompt): boolean | Promise<boolean>
+  stdin?: NodeJS.ReadStream
+  stdout?: NodeJS.WriteStream
+}
+
+interface Choice {
+  name: string
+  message?: string
+  value?: string
+  hint?: string
+  disabled?: boolean | string
+}
+
+interface ArrayPromptOptions$1 extends BasePromptOptions$1 {
+  type:
+    | 'autocomplete'
+    | 'editable'
+    | 'form'
+    | 'multiselect'
+    | 'select'
+    | 'survey'
+    | 'list'
+    | 'scale'
+  choices: string[] | Choice[]
+  maxChoices?: number
+  muliple?: boolean
+  initial?: number
+  delay?: number
+  separator?: boolean
+  sort?: boolean
+  linebreak?: boolean
+  edgeLength?: number
+  align?: 'left' | 'right'
+  scroll?: boolean
+}
+
+interface BooleanPromptOptions$1 extends BasePromptOptions$1 {
+  type: 'confirm'
+  initial?: boolean
+}
+
+interface StringPromptOptions$1 extends BasePromptOptions$1 {
+  type: 'input' | 'invisible' | 'list' | 'password' | 'text'
+  initial?: string
+  multiline?: boolean
+}
+
+interface NumberPromptOptions$1 extends BasePromptOptions$1 {
+  type: 'numeral'
+  min?: number
+  max?: number
+  delay?: number
+  float?: boolean
+  round?: boolean
+  major?: number
+  minor?: number
+  initial?: number
+}
+
+interface SnippetPromptOptions$1 extends BasePromptOptions$1 {
+  type: 'snippet'
+  newline?: string
+  template?: string
+}
+
+interface SortPromptOptions$1 extends BasePromptOptions$1 {
+  type: 'sort'
+  hint?: string
+  drag?: boolean
+  numbered?: boolean
+}
+
+type PromptOptions$1 =
+  | BasePromptOptions$1
+  | ArrayPromptOptions$1
+  | BooleanPromptOptions$1
+  | StringPromptOptions$1
+  | NumberPromptOptions$1
+  | SnippetPromptOptions$1
+  | SortPromptOptions$1
+
+declare class BasePrompt extends EventEmitter {
+    constructor(options?: PromptOptions$1);
+
+    render(): void;
+
+    run(): Promise<any>;
+  }
+
+declare class Enquirer<T = object> extends EventEmitter {
+  constructor(options?: object, answers?: T);
+
+  /**
+   * Register a custom prompt type.
+   *
+   * @param type
+   * @param fn `Prompt` class, or a function that returns a `Prompt` class.
+   */
+  register(type: string, fn: typeof BasePrompt | (() => typeof BasePrompt)): this;
+
+  /**
+   * Register a custom prompt type.
+   */
+  register(type: { [key: string]: typeof BasePrompt | (() => typeof BasePrompt) }): this;
+
+  /**
+   * Prompt function that takes a "question" object or array of question objects,
+   * and returns an object with responses from the user.
+   *
+   * @param questions Options objects for one or more prompts to run.
+   */
+  prompt(
+    questions:
+      | PromptOptions$1
+      | ((this: Enquirer) => PromptOptions$1)
+      | (PromptOptions$1 | ((this: Enquirer) => PromptOptions$1))[]
+  ): Promise<T>;
+
+  /**
+   * Use an enquirer plugin.
+   *
+   * @param plugin Plugin function that takes an instance of Enquirer.
+   */
+  use(plugin: (this: this, enquirer: this) => void): this;
+}
+
+declare namespace Enquirer {
+  function prompt<T = object>(
+    questions:
+      | PromptOptions$1
+      | ((this: Enquirer) => PromptOptions$1)
+      | (PromptOptions$1 | ((this: Enquirer) => PromptOptions$1))[]
+  ): Promise<T>;
+
+  class Prompt extends BasePrompt {}
+}
+
+/** Type of listr internal events. */
+declare enum ListrEventType {
+    TITLE = "TITLE",
+    STATE = "STATE",
+    ENABLED = "ENABLED",
+    SUBTASK = "SUBTASK",
+    DATA = "DATA",
+    MESSAGE = "MESSAGE"
+}
+
+/** Listr Default Context */
+declare type ListrContext = any | undefined;
+/**
+ * ListrTask.
+ *
+ * Defines the task, conditions and options to run a specific task in the listr.
+ */
+interface ListrTask<Ctx = ListrContext, Renderer extends ListrRendererFactory = any> {
+    /**
+     * Title of the task.
+     *
+     * Give this task a title if you want to track it by name in the current renderer.
+     *
+     * Tasks without a title will hide in the default renderer and are useful for running a background instance.
+     * On verbose renderer, state changes from these tasks will log as 'Task without a title.'
+     */
+    title?: string;
+    /**
+     * The task itself.
+     *
+     * Task can be a sync or async function, an Observable, or a Stream.
+     * Task will be executed, if the certain criteria of the state are met and whenever the time for that specific task has come.
+     */
+    task: (ctx: Ctx, task: TaskWrapper<Ctx, Renderer>) => void | ListrTaskResult<Ctx>;
+    /**
+     * Skip this task depending on the context.
+     *
+     * The function that has been passed in will be evaluated at the runtime when the task tries to initially run.
+     */
+    skip?: boolean | string | ((ctx: Ctx) => boolean | string | Promise<boolean | string>);
+    /**
+     * Enable a task depending on the context.
+     *
+     * The function that has been passed in will be evaluated at the initial creation of the Listr class for rendering purposes,
+     * as well as re-evaluated when the time for that specific task has come.
+     */
+    enabled?: boolean | ((ctx: Ctx) => boolean | Promise<boolean>);
+    /**
+     * Adds the given number of retry attempts to the task if the task fails.
+     */
+    retry?: number;
+    /**
+     * Runs a specific event if the current task or any of the subtasks has failed.
+     *
+     * Mostly useful for rollback purposes for subtasks.
+     * But can also be useful whenever a task is failed and some measures have to be taken to ensure the state is not changed.
+     */
+    rollback?: (ctx: Ctx, task: TaskWrapper<Ctx, Renderer>) => void | ListrTaskResult<Ctx>;
+    /**
+     * Set exit on the error option from task-level instead of setting it for all the subtasks.
+     */
+    exitOnError?: boolean | ((ctx: Ctx) => boolean | Promise<boolean>);
+    /**
+     * Per task options, that depends on the selected renderer.
+     *
+     * These options depend on the implementation of the selected renderer. If the selected renderer has no options it will
+     * be displayed as never.
+     */
+    options?: ListrGetRendererTaskOptions<Renderer>;
+}
+/**
+ * Options to set the behavior of this base task.
+ */
+interface ListrOptions<Ctx = ListrContext> {
+    /**
+     * To inject a context through this options wrapper. Context can also be defined in run time.
+     *
+     * @default {}
+     */
+    ctx?: Ctx;
+    /**
+     * Concurrency sets how many tasks will be run at the same time in parallel.
+     *
+     * @default false > Default is to run everything synchronously.
+     *
+     * `true` will set it to `Infinity`, `false` will set it to synchronous.
+     *
+     * If you pass in a `number` it will limit it to that number.
+     */
+    concurrent?: boolean | number;
+    /**
+     * Determine the default behavior of exiting on errors.
+     *
+     * @default true > exit on any error coming from the tasks.
+     */
+    exitOnError?: boolean;
+    /**
+     * Determine the behavior of exiting after rollback actions.
+     *
+     * This is independent of exitOnError, since failure of a rollback can be a more critical operation comparing to
+     * failing a single task.
+     *
+     * @default true > exit after rolling back tasks
+     */
+    exitAfterRollback?: boolean;
+    /**
+     * Collects errors to `ListrInstance.errors`
+     *
+     * This can take up a lot of memory, so disabling it can fix out-of-memory errors
+     *
+     * - 'full' will clone the current context and task in to the error instance
+     * - 'minimal' will only collect the error message and the location
+     * - false will collect no errors
+     *
+     * @default 'minimal'
+     */
+    collectErrors?: false | 'minimal' | 'full';
+    /**
+     * By default, Listr2 will track SIGINIT signal to update the renderer one last time before completely failing.
+     *
+     * @default true
+     */
+    registerSignalListeners?: boolean;
+    /**
+     * Determine the certain condition required to use the non-TTY renderer.
+     *
+     * @default null > handled internally
+     */
+    rendererFallback?: boolean | (() => boolean);
+    /**
+     * Determine the certain condition required to use the silent renderer.
+     *
+     * @default null > handled internally
+     */
+    rendererSilent?: boolean | (() => boolean);
+    /**
+     * Disabling the color, useful for tests and such.
+     *
+     * @default false
+     */
+    disableColor?: boolean;
+    /**
+     * Inject data directly to TaskWrapper.
+     */
+    injectWrapper?: {
+        enquirer?: Enquirer<object>;
+    };
+}
+/**
+ * Task can be set of sync or async function, an Observable or a stream.
+ */
+declare type ListrTaskResult<Ctx> = string | Promise<any> | Listr<Ctx, ListrRendererValue, any> | Readable | NodeJS.ReadableStream | Observable<any>;
+/**
+ * Parent class options.
+ *
+ * Parent class has more options where you can also select the and set renderer and non-tty renderer.
+ *
+ * Any subtasks will respect those options so they will be stripped of that properties.
+ */
+declare type ListrBaseClassOptions<Ctx = ListrContext, Renderer extends ListrRendererValue = ListrDefaultRendererValue, FallbackRenderer extends ListrRendererValue = ListrFallbackRendererValue> = ListrOptions<Ctx> & ListrDefaultRendererOptions<Renderer> & ListrDefaultNonTTYRendererOptions<FallbackRenderer>;
+/**
+ * Sub class options.
+ *
+ * Subtasks has reduced set options where the missing ones are explicitly set by the base class.
+ */
+declare type ListrSubClassOptions<Ctx = ListrContext, Renderer extends ListrRendererValue = ListrDefaultRendererValue> = ListrOptions<Ctx> & Omit<ListrDefaultRendererOptions<Renderer>, 'renderer'>;
+/** The internal communication event. */
+declare type ListrEvent = {
+    type: Exclude<ListrEventType, 'MESSAGE' | 'DATA'>;
+    data?: string | boolean;
+} | {
+    type: ListrEventType.DATA;
+    data: string;
+} | {
+    type: ListrEventType.MESSAGE;
+    data: Task$1<any, any>['message'];
+};
+/**
+ * Used to match event.type to ListrEvent permutations
+ */
+declare type ListrEventFromType<T extends ListrEventType, E = ListrEvent> = E extends {
+    type: infer U;
+} ? T extends U ? E : never : never;
+
+interface BasePromptOptions {
+    message: string | (() => string) | (() => Promise<string>);
+    initial?: boolean | number | number[] | string | (() => string) | (() => Promise<string>);
+    required?: boolean;
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    header?: string;
+    footer?: string;
+    skip?: (value: any) => boolean | Promise<boolean>;
+    format?: (value: any) => any | Promise<any>;
+    result?: (value: any) => any | Promise<any>;
+    validate?: (value: any, state: any) => boolean | Promise<boolean> | string | Promise<string> | Promise<string | boolean>;
+    onSubmit?: (name: any, value: any, prompt: Enquirer.Prompt) => boolean | Promise<boolean>;
+    onCancel?: (name: any, value: any, prompt: Enquirer.Prompt) => boolean | Promise<boolean>;
+}
+interface BasePromptOptionsWithName extends BasePromptOptions {
+    name: string | (() => string);
+}
+interface ArrayPromptOptions extends BasePromptOptions {
+    choices: string[] | BasePromptOptionsWithName[];
+    maxChoices?: number;
+    multiple?: boolean;
+    initial?: number | number[];
+    delay?: number;
+    separator?: boolean;
+    sort?: boolean;
+    linebreak?: boolean;
+    edgeLength?: number;
+    align?: 'left' | 'right';
+    scroll?: boolean;
+    hint?: string;
+}
+interface BooleanPromptOptions extends BasePromptOptions {
+    initial?: boolean | (() => string) | (() => Promise<string>);
+}
+interface StringPromptOptions extends BasePromptOptions {
+    initial?: string;
+    multiline?: boolean;
+}
+interface ScalePromptOptions extends ArrayPromptOptions {
+    scale: StringPromptOptions[];
+    margin?: [number, number, number, number];
+}
+interface NumberPromptOptions extends BasePromptOptions {
+    min?: number;
+    max?: number;
+    delay?: number;
+    float?: boolean;
+    round?: boolean;
+    major?: number;
+    minor?: number;
+    initial?: number;
+}
+interface SnippetPromptOptions extends BasePromptOptions {
+    newline?: string;
+    fields: Partial<BasePromptOptionsWithName>[];
+    template: string;
+}
+interface SortPromptOptions extends BasePromptOptions {
+    hint?: string;
+    drag?: boolean;
+    numbered?: boolean;
+}
+interface SurveyPromptOptions extends ArrayPromptOptions {
+    scale: BasePromptOptionsWithName[];
+    margin: [number, number, number, number];
+}
+interface QuizPromptOptions extends ArrayPromptOptions {
+    correctChoice: number;
+}
+interface TogglePromptOptions extends BasePromptOptions {
+    enabled?: string;
+    disabled?: string;
+}
+/** Returns all the prompt options depending on the type selected. */
+declare type PromptOptions<T extends boolean = false> = Unionize<{
+    [K in PromptTypes]-?: T extends true ? {
+        type: K;
+    } & PromptOptionsType<K> & {
+        name: string | (() => string);
+    } : {
+        type: K;
+    } & PromptOptionsType<K>;
+}> | ({
+    type: string;
+} & T extends true ? PromptOptionsType<string> & {
+    name: string | (() => string);
+} : PromptOptionsType<string>);
+declare type Unionize<T extends Record<PropertyKey, unknown>> = {
+    [P in keyof T]: T[P];
+}[keyof T];
+declare type PromptTypes = 'AutoComplete' | 'BasicAuth' | 'Confirm' | 'Editable' | 'Form' | 'Input' | 'Invisible' | 'List' | 'MultiSelect' | 'Numeral' | 'Password' | 'Quiz' | 'Scale' | 'Select' | 'Snippet' | 'Sort' | 'Survey' | 'Text' | 'Toggle';
+declare type PromptOptionsType<T> = T extends keyof PromptOptionsMap ? PromptOptionsMap[T] : T extends string ? BasePromptOptions & Record<PropertyKey, unknown> : any;
+declare class PromptOptionsMap implements Record<PromptTypes, Record<PropertyKey, any>> {
+    AutoComplete: ArrayPromptOptions;
+    BasicAuth: StringPromptOptions;
+    Confirm: BooleanPromptOptions;
+    Editable: ArrayPromptOptions;
+    Form: ArrayPromptOptions;
+    Input: StringPromptOptions;
+    Invisible: StringPromptOptions;
+    List: ArrayPromptOptions;
+    MultiSelect: ArrayPromptOptions;
+    Numeral: NumberPromptOptions;
+    Password: StringPromptOptions;
+    Quiz: QuizPromptOptions;
+    Scale: ScalePromptOptions;
+    Select: ArrayPromptOptions;
+    Snippet: SnippetPromptOptions;
+    Sort: SortPromptOptions;
+    Survey: SurveyPromptOptions;
+    Text: StringPromptOptions;
+    Toggle: TogglePromptOptions;
+}
+interface PromptInstance extends Omit<BasePromptOptions, 'onCancel' | 'onSubmit'> {
+    submit: () => void;
+    cancel: (err?: string) => void;
+}
+
+/**
+ * Extend the task to have more functionality while accesing from the outside.
+ */
+declare class TaskWrapper<Ctx, Renderer extends ListrRendererFactory> {
+    task: Task$1<Ctx, ListrRendererFactory>;
+    errors: ListrError<Ctx>[];
+    private options;
+    constructor(task: Task$1<Ctx, ListrRendererFactory>, errors: ListrError<Ctx>[], options: ListrBaseClassOptions<Ctx, any, any>);
+    /** Get the title of the current task. */
+    get title(): string;
+    /** Change the title of the current task. */
+    set title(data: string);
+    /** Get the output from the output channel. */
+    get output(): string;
+    /** Send a output to the output channel. */
+    set output(data: string);
+    /** Create a new subtask with given renderer selection from the parent task. */
+    newListr<NewCtx = Ctx>(task: ListrTask<NewCtx, Renderer> | ListrTask<NewCtx, Renderer>[] | ((parent: Omit<this, 'skip' | 'enabled'>) => ListrTask<NewCtx, Renderer> | ListrTask<NewCtx, Renderer>[]), options?: ListrSubClassOptions<NewCtx, Renderer>): Listr<NewCtx, any, any>;
+    /** Report a error in process for error collection. */
+    report(error: Error, type: ListrErrorTypes): void;
+    /** Skip current task. */
+    skip(message?: string): void;
+    /** Get the number of retrying, else returns false */
+    isRetrying(): Task$1<Ctx, Renderer>['retry'];
+    /**
+     * Create a new Enquirer prompt using prompt options.
+     *
+     * Since process.stdout is controlled by Listr, this will passthrough all Enquirer data through internal stdout.
+     */
+    prompt<T = any>(options: PromptOptions | PromptOptions<true>[]): Promise<T>;
+    /** Cancels the current prompt attach to this task. */
+    cancelPrompt(throwError?: boolean): void;
+    /**
+     * Pass stream of data to internal stdout.
+     *
+     * Since Listr2 takes control of process.stdout utilizing the default renderer, any data outputted to process.stdout
+     * will corupt its looks.
+     *
+     * This returns a fake stream to pass any stream inside Listr as task data.
+     */
+    stdout(): NodeJS.WriteStream & NodeJS.WritableStream;
+    /** Run this task. */
+    run(ctx: Ctx): Promise<void>;
+}
+
+/** Available task states. */
+declare enum ListrTaskState {
+    PENDING = "PENDING",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    SKIPPED = "SKIPPED",
+    ROLLING_BACK = "ROLLING_BACK",
+    ROLLED_BACK = "ROLLED_BACK",
+    RETRY = "RETRY"
+}
+
+/**
+ * Create a task from the given set of variables and make it runnable.
+ */
+declare class Task$1<Ctx, Renderer extends ListrRendererFactory> extends Subject<ListrEvent> {
+    listr: Listr<Ctx, any, any>;
+    tasks: ListrTask<Ctx, any>;
+    options: ListrOptions;
+    rendererOptions: ListrGetRendererOptions<Renderer>;
+    /** Unique id per task, randomly generated in the uuid v4 format */
+    id: string;
+    /** The current state of the task. */
+    state: string;
+    /** The task object itself, to further utilize it. */
+    task: (ctx: Ctx, task: TaskWrapper<Ctx, Renderer>) => void | ListrTaskResult<Ctx>;
+    /** Extend current task with multiple subtasks. */
+    subtasks: Task$1<Ctx, any>[];
+    /** Title of the task */
+    title?: string;
+    /** Untouched unchanged title of the task */
+    initialTitle?: string;
+    /** Output data from the task. */
+    output?: string;
+    /** Skip current task. */
+    skip: boolean | string | ((ctx: Ctx) => boolean | string | Promise<boolean | string>);
+    /** Current retry number of the task if retrying */
+    retry?: {
+        count: number;
+        withError?: any;
+    };
+    /**
+     * A channel for messages.
+     *
+     * This requires a separate channel for messages like error, skip or runtime messages to further utilize in the renderers.
+     */
+    message: {
+        /** Run time of the task, if it has been successfully resolved. */
+        duration?: number;
+        /** Error message of the task, if it has been failed. */
+        error?: string;
+        /** Skip message of the task, if it has been skipped. */
+        skip?: string;
+        /** Rollback message of the task, if the rollback finishes */
+        rollback?: string;
+        /** Retry messages */
+        retry?: {
+            count: number;
+            withError?: any;
+        };
+    };
+    /** Per task options for the current renderer of the task. */
+    rendererTaskOptions: ListrGetRendererTaskOptions<Renderer>;
+    /** This will be triggered each time a new render should happen. */
+    renderHook$: Subject<void>;
+    prompt: undefined | PromptInstance | PromptError;
+    private enabled;
+    private enabledFn;
+    constructor(listr: Listr<Ctx, any, any>, tasks: ListrTask<Ctx, any>, options: ListrOptions, rendererOptions: ListrGetRendererOptions<Renderer>);
+    set state$(state: ListrTaskState);
+    set output$(data: string);
+    set message$(data: Task$1<Ctx, Renderer>['message']);
+    set title$(title: string);
+    /**
+     * A function to check whether this task should run at all via enable.
+     */
+    check(ctx: Ctx): Promise<void>;
+    /** Returns whether this task has subtasks. */
+    hasSubtasks(): boolean;
+    /** Returns whether this task is in progress. */
+    isPending(): boolean;
+    /** Returns whether this task is skipped. */
+    isSkipped(): boolean;
+    /** Returns whether this task has been completed. */
+    isCompleted(): boolean;
+    /** Returns whether this task has been failed. */
+    hasFailed(): boolean;
+    /** Returns whether this task has an active rollback task going on. */
+    isRollingBack(): boolean;
+    /** Returns whether the rollback action was successful. */
+    hasRolledBack(): boolean;
+    /** Returns whether this task has an actively retrying task going on. */
+    isRetrying(): boolean;
+    /** Returns whether enabled function resolves to true. */
+    isEnabled(): boolean;
+    /** Returns whether this task actually has a title. */
+    hasTitle(): boolean;
+    /** Returns whether this task has a prompt inside. */
+    isPrompt(): boolean;
+    /** Run the current task. */
+    run(context: Ctx, wrapper: TaskWrapper<Ctx, Renderer>): Promise<void>;
+}
+
+/** Default updating renderer for Listr2 */
+declare class DefaultRenderer implements ListrRenderer {
+    tasks: Task$1<any, typeof DefaultRenderer>[];
+    options: typeof DefaultRenderer['rendererOptions'];
+    renderHook$?: Task$1<any, any>['renderHook$'];
+    /** designates whether this renderer can output to a non-tty console */
+    static nonTTY: boolean;
+    /** renderer options for the defauult renderer */
+    static rendererOptions: {
+        /**
+         * indentation per level of subtask
+         *
+         * @default 2
+         */
+        indentation?: number;
+        /**
+         * clear all the output generated by the renderer when the task finishes its execution
+         *
+         * @default false
+         * @global global option that can not be temperated with subtasks
+         */
+        clearOutput?: boolean;
+        /**
+         * show the subtasks of the current task
+         *
+         * @default true
+         */
+        showSubtasks?: boolean;
+        /**
+         * collapse subtasks after current task completes its execution
+         *
+         * @default true
+         */
+        collapse?: boolean;
+        /**
+         * show skip messages or show the original title of the task, this will also disable collapseSkips mode
+         *
+         * You can disable showing the skip messages, even though you passed in a message by settings this option,
+         * if you want to keep the original task title intact.
+         *
+         * @default true
+         */
+        showSkipMessage?: boolean;
+        /**
+         * collapse skip messages into a single message and overwrite the task title
+         *
+         * @default true
+         */
+        collapseSkips?: boolean;
+        /**
+         * suffix skip messages with [SKIPPED] when in collapseSkips mode
+         *
+         * @default true
+         */
+        suffixSkips?: boolean;
+        /**
+         * shows the thrown error message or show the original title of the task, this will also disable collapseErrors mode
+         * You can disable showing the error messages, even though you passed in a message by settings this option,
+         * if you want to keep the original task title intact.
+         *
+         * @default true
+         */
+        showErrorMessage?: boolean;
+        /**
+         * collapse error messages into a single message and overwrite the task title
+         *
+         * @default true
+         */
+        collapseErrors?: boolean;
+        /**
+         * suffix retry messages with [RETRY-${COUNT}] when retry is enabled for a task
+         *
+         * @default true
+         */
+        suffixRetries?: boolean;
+        /**
+         * only update through triggers from renderhook
+         *
+         * useful for tests and stuff. this will disable showing spinner and only update the screen if something else has
+         * happened in the task worthy to show
+         *
+         * @default false
+         * @global global option that can not be temperated with subtasks
+         */
+        lazy?: boolean;
+        /**
+         * show duration for all tasks
+         *
+         * @default false
+         * @global global option that can not be temperated with subtasks
+         */
+        showTimer?: boolean;
+        /**
+         * removes empty lines from the data output
+         *
+         * @default true
+         */
+        removeEmptyLines?: boolean;
+        /**
+         * formats data output depending on your requirements.
+         *
+         * @default 'truncate'
+         * @global global option that can not be temperated with subtasks
+         */
+        formatOutput?: 'truncate' | 'wrap';
+    };
+    /** per task options for the default renderer */
+    static rendererTaskOptions: {
+        /**
+         * write task output to the bottom bar instead of the gap under the task title itself.
+         * useful for a stream of data.
+         * @default false
+         *
+         * `true` only keep 1 line of the latest data outputted by the task.
+         * `false` only keep 1 line of the latest data outputted by the task.
+         * `number` will keep designated data of the latest data outputted by the task.
+         */
+        bottomBar?: boolean | number;
+        /**
+         * keep output after task finishes
+         * @default false
+         *
+         * works both for the bottom bar and the default behavior
+         */
+        persistentOutput?: boolean;
+        /**
+         * show the task time if it was successful
+         */
+        showTimer?: boolean;
+    };
+    private id?;
+    private bottomBar;
+    private promptBar;
+    private readonly spinner;
+    private spinnerPosition;
+    constructor(tasks: Task$1<any, typeof DefaultRenderer>[], options: typeof DefaultRenderer['rendererOptions'], renderHook$?: Task$1<any, any>['renderHook$']);
+    getTaskOptions(task: Task$1<any, typeof DefaultRenderer>): typeof DefaultRenderer['rendererTaskOptions'];
+    isBottomBar(task: Task$1<any, typeof DefaultRenderer>): boolean;
+    hasPersistentOutput(task: Task$1<any, typeof DefaultRenderer>): boolean;
+    hasTimer(task: Task$1<any, typeof DefaultRenderer>): boolean;
+    getSelfOrParentOption<T extends keyof typeof DefaultRenderer['rendererOptions']>(task: Task$1<any, typeof DefaultRenderer>, key: T): typeof DefaultRenderer['rendererOptions'][T];
+    getTaskTime(task: Task$1<any, typeof DefaultRenderer>): string;
+    createRender(options?: {
+        tasks?: boolean;
+        bottomBar?: boolean;
+        prompt?: boolean;
+    }): string;
+    render(): void;
+    end(): void;
+    private multiLineRenderer;
+    private renderBottomBar;
+    private renderPrompt;
+    private dumpData;
+    private formatString;
+    private indentMultilineOutput;
+    private getSymbol;
+    private addSuffixToMessage;
+}
+
+declare class SilentRenderer implements ListrRenderer {
+    tasks: Task$1<any, typeof SilentRenderer>[];
+    options: typeof SilentRenderer['rendererOptions'];
+    /** designates whether this renderer can output to a non-tty console */
+    static nonTTY: boolean;
+    /** renderer options for the silent renderer */
+    static rendererOptions: never;
+    /** per task options for the silent renderer */
+    static rendererTaskOptions: never;
+    constructor(tasks: Task$1<any, typeof SilentRenderer>[], options: typeof SilentRenderer['rendererOptions']);
+    render(): void;
+    end(): void;
+}
+
+/**
+ * This is the default renderer which is neither verbose or updating.
+ * It provides short output like update renderer, but does not disturb
+ * stdin during execution of listr tasks
+ */
+declare class SimpleRenderer implements ListrRenderer {
+    readonly tasks: Task$1<any, typeof SimpleRenderer>[];
+    options: typeof SimpleRenderer['rendererOptions'];
+    static nonTTY: boolean;
+    static rendererOptions: {
+        /**
+         * if true this will add
+         * timestamp at the begin of the rendered line
+         *
+         * @example
+         *
+         * ```bash
+         * [12:33:44] ✔ Do something important
+         * ```
+         *
+         * @default false
+         */
+        prefixWithTimestamp?: boolean;
+        /**
+         * choose between process.stdout and process.stderr
+         *
+         * @default stdout
+         */
+        output?: 'stdout' | 'stderr';
+    };
+    static rendererTaskOptions: never;
+    /**
+     * Event type renderer map contains functions to process different task events
+     */
+    eventTypeRendererMap: Partial<{
+        [P in ListrEventType]: (t: Task$1<any, typeof SimpleRenderer>, event: ListrEventFromType<P>) => void;
+    }>;
+    constructor(tasks: Task$1<any, typeof SimpleRenderer>[], options: typeof SimpleRenderer['rendererOptions']);
+    static now(): Date;
+    static formatTitle(task?: Task$1<any, typeof SimpleRenderer>): string;
+    log(output?: string): void;
+    end(): void;
+    render(tasks?: Task$1<any, typeof SimpleRenderer>[]): void;
+}
+
+/** Default loglevels for the logger */
+declare enum LogLevels {
+    SILENT = "SILENT",
+    FAILED = "FAILED",
+    SKIPPED = "SKIPPED",
+    SUCCESS = "SUCCESS",
+    DATA = "DATA",
+    STARTED = "STARTED",
+    TITLE = "TITLE",
+    RETRY = "RETRY",
+    ROLLBACK = "ROLLBACK"
+}
+
+/**
+ * Options for the logger
+ */
+interface LoggerOptions {
+    useIcons: boolean;
+}
+
+/**
+ * A internal logger for using in the verbose renderer mostly.
+ */
+declare class Logger {
+    private options?;
+    constructor(options?: LoggerOptions);
+    fail(message: string): void;
+    skip(message: string): void;
+    success(message: string): void;
+    data(message: string): void;
+    start(message: string): void;
+    title(message: string): void;
+    retry(message: string): void;
+    rollback(message: string): void;
+    protected parseMessage(level: LogLevels, message: string): string;
+    protected logColoring({ level, message }: {
+        level: LogLevels;
+        message: string;
+    }): string;
+    private wrapInBrackets;
+}
+
+declare class VerboseRenderer implements ListrRenderer {
+    tasks: Task$1<any, typeof VerboseRenderer>[];
+    options: typeof VerboseRenderer['rendererOptions'];
+    /** designates whether this renderer can output to a non-tty console */
+    static nonTTY: boolean;
+    /** renderer options for the verbose renderer */
+    static rendererOptions: ({
+        /**
+             * useIcons instead of text for log level
+             * @default false
+             */
+        useIcons?: boolean;
+        /**
+             * log tasks with empty titles
+             * @default true
+             */
+        logEmptyTitle?: boolean;
+        /**
+             * log title changes
+             * @default true
+             */
+        logTitleChange?: boolean;
+        /**
+             * show duration for all tasks
+             */
+        showTimer?: boolean;
+    } & {
+        /**
+             * inject a custom logger
+             */
+        logger?: new (...args: any) => Logger;
+        /**
+             * inject options to custom logger
+             */
+        options?: any;
+    });
+    /** per task options for the verbose renderer */
+    static rendererTaskOptions: never;
+    private logger;
+    constructor(tasks: Task$1<any, typeof VerboseRenderer>[], options: typeof VerboseRenderer['rendererOptions']);
+    render(): void;
+    end(): void;
+    private verboseRenderer;
+}
+
+/** The default renderer value used in Listr2 applications */
+declare type ListrDefaultRendererValue = 'default';
+/** Type of default renderer */
+declare type ListrDefaultRenderer = typeof DefaultRenderer;
+/** Name of default fallback renderer */
+declare type ListrFallbackRendererValue = 'verbose';
+/** Type of default fallback renderer */
+declare type ListrFallbackRenderer = typeof VerboseRenderer;
+/** Silent rendere for internal usage */
+declare type ListrSilentRendererValue = 'silent';
+/** Typeof silent renderer */
+declare type ListrSilentRenderer = typeof SilentRenderer;
+/** Simple renderer that simplifies things */
+declare type ListrSimpleRendererValue = 'simple';
+/** Typeof simple renderer */
+declare type ListrSimpleRenderer = typeof SimpleRenderer;
+/**
+ * Listr2 can process either the integrated renderers as string aliases,
+ * or utilize a compatible style renderer that extends the ListrRenderer abstract class.
+ */
+declare type ListrRendererValue = ListrSilentRendererValue | ListrDefaultRendererValue | ListrSimpleRendererValue | ListrFallbackRendererValue | ListrRendererFactory;
+/**
+ * Returns the class type from friendly names of the renderers.
+ */
+declare type ListrGetRendererClassFromValue<T extends ListrRendererValue> = T extends ListrDefaultRendererValue ? ListrDefaultRenderer : T extends ListrSimpleRendererValue ? ListrSimpleRenderer : T extends ListrFallbackRendererValue ? ListrFallbackRenderer : T extends ListrSilentRenderer ? ListrSilentRenderer : T extends ListrRendererFactory ? T : never;
+/**
+ * Returns renderer global options depending on the renderer type.
+ */
+declare type ListrGetRendererOptions<T extends ListrRendererValue> = T extends ListrDefaultRendererValue ? ListrDefaultRenderer['rendererOptions'] : T extends ListrSimpleRendererValue ? ListrSimpleRenderer['rendererOptions'] : T extends ListrFallbackRendererValue ? ListrFallbackRenderer['rendererOptions'] : T extends ListrSilentRenderer ? ListrSilentRenderer['rendererOptions'] : T extends ListrRendererFactory ? T['rendererOptions'] : never;
+/**
+ * Returns renderer per task options depending on the renderer type.
+ */
+declare type ListrGetRendererTaskOptions<T extends ListrRendererValue> = T extends ListrDefaultRendererValue ? ListrDefaultRenderer['rendererTaskOptions'] : T extends ListrSimpleRendererValue ? ListrSimpleRenderer : T extends ListrFallbackRendererValue ? ListrFallbackRenderer['rendererTaskOptions'] : T extends ListrSilentRenderer ? ListrSilentRenderer['rendererTaskOptions'] : T extends ListrRendererFactory ? T['rendererTaskOptions'] : never;
+/** Select renderer as default renderer */
+interface ListrDefaultRendererOptions<T extends ListrRendererValue> {
+    /** the default renderer */
+    renderer?: T;
+    /** Renderer options depending on the current renderer */
+    rendererOptions?: ListrGetRendererOptions<T>;
+}
+/** Select a fallback renderer to fallback to in non-tty conditions */
+interface ListrDefaultNonTTYRendererOptions<T extends ListrRendererValue> {
+    /** the fallback renderer to fallback to on non-tty conditions */
+    nonTTYRenderer?: T;
+    /** Renderer options depending on the current renderer */
+    nonTTYRendererOptions?: ListrGetRendererOptions<T>;
+}
+/** The bones of a listr renderer. */
+declare class ListrRenderer {
+    /** designate renderer global options that is specific to the current renderer */
+    static rendererOptions: Record<PropertyKey, any>;
+    /** designate renderer per task options that is specific to the current renderer  */
+    static rendererTaskOptions: Record<PropertyKey, any>;
+    /** designate whether this renderer can work in non-tty environments */
+    static nonTTY: boolean;
+    /** A function to what to do on render */
+    render: () => void;
+    /** A function to what to do on end of the render */
+    end: (err?: Error) => void;
+    /** create a new renderer */
+    constructor(tasks: readonly Task$1<any, ListrRendererFactory>[], options: typeof ListrRenderer.rendererOptions, renderHook$?: Subject<void>);
+}
+/** A renderer factory from the current type */
+declare type ListrRendererFactory = typeof ListrRenderer;
+
+/** The internal error handling mechanism.. */
+declare class ListrError<Ctx extends Record<PropertyKey, any> = Record<PropertyKey, any>> extends Error {
+    error: Error;
+    type: ListrErrorTypes;
+    task: Task$1<Ctx, ListrRendererFactory>;
+    path: string;
+    ctx: Ctx;
+    constructor(error: Error, type: ListrErrorTypes, task: Task$1<Ctx, ListrRendererFactory>);
+}
+/**
+ * The actual error type that is collected and to help identify where the error is triggered from.
+ */
+declare enum ListrErrorTypes {
+    /** Task has failed and will try to retry. */
+    WILL_RETRY = "WILL_RETRY",
+    /** Task has failed and will try to rollback. */
+    WILL_ROLLBACK = "WILL_ROLLBACK",
+    /** Task has failed, ran the rollback action but the rollback action itself has failed. */
+    HAS_FAILED_TO_ROLLBACK = "HAS_FAILED_TO_ROLLBACK",
+    /** Task has failed. */
+    HAS_FAILED = "HAS_FAILED",
+    /** Task has failed, but exitOnError is set to false, so will ignore this error. */
+    HAS_FAILED_WITHOUT_ERROR = "HAS_FAILED_WITHOUT_ERROR"
+}
+/** The internal error handling mechanism for prompts only. */
+declare class PromptError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Creates a new set of Listr2 task list.
+ */
+declare class Listr<Ctx = ListrContext, Renderer extends ListrRendererValue = ListrDefaultRendererValue, FallbackRenderer extends ListrRendererValue = ListrFallbackRendererValue> {
+    task: ListrTask<Ctx, ListrGetRendererClassFromValue<Renderer>> | ListrTask<Ctx, ListrGetRendererClassFromValue<Renderer>>[];
+    options?: ListrBaseClassOptions<Ctx, Renderer, FallbackRenderer>;
+    parentTask?: Task$1<any, any>;
+    tasks: Task$1<Ctx, ListrGetRendererClassFromValue<Renderer>>[];
+    err: ListrError<Ctx>[];
+    ctx: Ctx;
+    rendererClass: ListrRendererFactory;
+    rendererClassOptions: ListrGetRendererOptions<ListrRendererFactory>;
+    renderHook$: Task$1<any, any>['renderHook$'];
+    path: string[];
+    private concurrency;
+    private renderer;
+    constructor(task: ListrTask<Ctx, ListrGetRendererClassFromValue<Renderer>> | ListrTask<Ctx, ListrGetRendererClassFromValue<Renderer>>[], options?: ListrBaseClassOptions<Ctx, Renderer, FallbackRenderer>, parentTask?: Task$1<any, any>);
+    add(task: ListrTask<Ctx, ListrGetRendererClassFromValue<Renderer>> | ListrTask<Ctx, ListrGetRendererClassFromValue<Renderer>>[]): void;
+    run(context?: Ctx): Promise<Ctx>;
+    private checkAll;
+    private runTask;
+}
+
 interface Question {
     type: 'input' | 'select';
     name: string;
     message: string;
+    validate?: (value: string) => string | boolean;
     default?: string;
-    choices?: string[];
+    choices?: string[] | {
+        name: string;
+        value: string;
+    }[];
 }
 declare const prompt: <T>(questions: Question[]) => Promise<T>;
-interface Task$1 {
-    title: string;
-    output: string;
-}
-interface Context {
-}
-interface ListTask {
-    title: string;
-    task: (ctx: Context, task: Task$1) => Promise<void>;
-}
-interface ListOptions {
-    concurrent?: boolean;
-}
-declare const list: (tasks: ListTask[], options?: ListOptions | undefined) => Promise<void>;
 
 type ui_Question = Question;
 declare const ui_prompt: typeof prompt;
-type ui_Context = Context;
-declare const ui_list: typeof list;
+type ui_Listr<Ctx = ListrContext, Renderer extends ListrRendererValue = ListrDefaultRendererValue, FallbackRenderer extends ListrRendererValue = ListrFallbackRendererValue> = Listr<Ctx, Renderer, FallbackRenderer>;
+declare const ui_Listr: typeof Listr;
 declare namespace ui {
   export {
     ui_Question as Question,
     ui_prompt as prompt,
-    Task$1 as Task,
-    ui_Context as Context,
-    ui_list as list,
+    ui_Listr as Listr,
   };
 }
 
@@ -90,6 +1466,7 @@ interface ExecOptions {
     stdout?: Writable;
     stderr?: Writable;
 }
+declare const open: (url: string) => Promise<void>;
 /**
  * Runs a command asynchronously, aggregates the stdout data, and returns it.
  * @param command {string} Command to be executed.
@@ -100,15 +1477,15 @@ declare const captureOutput: (command: string, args: string[]) => Promise<string
 declare const exec: (command: string, args: string[], options?: ExecOptions | undefined) => Promise<void>;
 
 type system_ExecOptions = ExecOptions;
+declare const system_open: typeof open;
 declare const system_captureOutput: typeof captureOutput;
 declare const system_exec: typeof exec;
-declare const system_open: typeof open;
 declare namespace system {
   export {
     system_ExecOptions as ExecOptions,
+    system_open as open,
     system_captureOutput as captureOutput,
     system_exec as exec,
-    system_open as open,
   };
 }
 
@@ -144,6 +1521,8 @@ declare function camelCase(input: string, options?: Options$4): string;
 
 declare function paramCase(input: string, options?: Options$4): string;
 
+declare function snakeCase(input: string, options?: Options$4): string;
+
 /** Returns a random string */
 declare function randomHex(size: number): string;
 declare function generateRandomChallengePair(): {
@@ -159,6 +1538,7 @@ declare namespace string {
     string_generateRandomChallengePair as generateRandomChallengePair,
     camelCase as camelize,
     paramCase as hyphenize,
+    snakeCase as underscore,
   };
 }
 
@@ -175,7 +1555,7 @@ declare const relative: typeof path$1.relative;
 declare const dirname: typeof path$1.dirname;
 declare const format: typeof path$1.format;
 declare const basename: typeof path$1.basename;
-declare const parse$1: typeof path$1.parse;
+declare const parse: typeof path$1.parse;
 
 interface Options$3 {
 	/**
@@ -498,6 +1878,7 @@ declare const path_isAbsolute: typeof isAbsolute;
 declare const path_join: typeof join;
 declare const path_normalize: typeof normalize;
 declare const path_normalizeString: typeof normalizeString;
+declare const path_parse: typeof parse;
 declare const path_relative: typeof relative;
 declare const path_resolve: typeof resolve;
 declare const path_sep: typeof sep;
@@ -515,7 +1896,7 @@ declare namespace path {
     path_join as join,
     path_normalize as normalize,
     path_normalizeString as normalizeString,
-    parse$1 as parse,
+    path_parse as parse,
     path_relative as relative,
     path_resolve as resolve,
     path_sep as sep,
@@ -523,6 +1904,11 @@ declare namespace path {
   };
 }
 
+/**
+ * Creates a temporary directory and ties its lifecycle ot the lifecycle of the callback.
+ * @param callback - The callback that receives the temporary directory.
+ */
+declare function inTemporaryDirectory<T>(callback: (tmpDir: string) => T | Promise<T>): Promise<T>;
 /**
  * It reads a file and returns its content as a string using the
  * utf-8 encoding
@@ -537,29 +1923,65 @@ declare function read(path: string): Promise<string>;
  */
 declare function copy(from: string, to: string): Promise<void>;
 declare function write(path: string, data: string): Promise<void>;
+declare function append(path: string, data: string): Promise<void>;
 declare function mkdir(path: string): Promise<void>;
 declare function rmdir(path: string): Promise<void>;
 declare function mkTmpDir(): Promise<string>;
 declare function isDirectory(path: string): Promise<boolean>;
+/**
+ * Moves a file.
+ * @param src {string} File to be moved.
+ * @param dest {string} Path to be moved to.
+ * @param options {object} Moving options.
+ */
+declare function move(src: string, dest: string, options?: {
+    overwrite?: boolean;
+}): Promise<void>;
+/**
+ * Changes the permissions of a directory or file.
+ * @param path {string} Path to the file or directory whose permissions will be modified.
+ * @param mode {string | numbers} Permissions to set to the file or directory.
+ */
+declare function chmod(path: string, mode: number | string): Promise<void>;
+/**
+ * Checks if a file has executable permissions.
+ * @param path {string} Path to the file whose permissions will be checked.
+ */
+declare function hasExecutablePermissions(path: string): Promise<boolean>;
+/**
+ * Returns true if a file or directory exists
+ * @param path {string} Path to the directory or file.
+ * @returns {boolean} True if it exists.
+ */
 declare function exists(path: string): Promise<boolean>;
 
+declare const file_inTemporaryDirectory: typeof inTemporaryDirectory;
 declare const file_read: typeof read;
 declare const file_copy: typeof copy;
 declare const file_write: typeof write;
+declare const file_append: typeof append;
 declare const file_mkdir: typeof mkdir;
 declare const file_rmdir: typeof rmdir;
 declare const file_mkTmpDir: typeof mkTmpDir;
 declare const file_isDirectory: typeof isDirectory;
+declare const file_move: typeof move;
+declare const file_chmod: typeof chmod;
+declare const file_hasExecutablePermissions: typeof hasExecutablePermissions;
 declare const file_exists: typeof exists;
 declare namespace file {
   export {
+    file_inTemporaryDirectory as inTemporaryDirectory,
     file_read as read,
     file_copy as copy,
     file_write as write,
+    file_append as append,
     file_mkdir as mkdir,
     file_rmdir as rmdir,
     file_mkTmpDir as mkTmpDir,
     file_isDirectory as isDirectory,
+    file_move as move,
+    file_chmod as chmod,
+    file_hasExecutablePermissions as hasExecutablePermissions,
     file_exists as exists,
   };
 }
@@ -589,25 +2011,82 @@ declare class TokenizedString {
 }
 declare type Message = string | TokenizedString;
 declare function content(strings: TemplateStringsArray, ...keys: (ContentToken | string)[]): TokenizedString;
+/** Log levels */
+declare type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silent';
+/**
+ *
+ * @returns {LogLevel} It returns the log level set by the user.
+ */
+declare const currentLogLevel: () => LogLevel;
+declare const shouldOutput: (logLevel: LogLevel) => boolean;
+/**
+ * Ouputs information to the user. This is akin to "console.log"
+ * Info messages don't get additional formatting.
+ * Note: Info messages are sent through the standard output.
+ * @param content {string} The content to be output to the user.
+ */
+declare const info: (content: Message) => void;
+/**
+ * Outputs a success message to the user.
+ * Success message receive a special formatting to make them stand out in the console.
+ * Note: Success messages are sent through the standard output.
+ * @param content {string} The content to be output to the user.
+ */
 declare const success: (content: Message) => void;
-declare const message: (content: Message) => void;
-declare const error: (content: Message) => void;
-declare const warning: (content: Message) => void;
+/**
+ * Ouputs debug information to the user. By default these output is hidden unless the user calls the CLI with --verbose.
+ * Debug messages don't get additional formatting.
+ * Note: Debug messages are sent through the standard output.
+ * @param content {string} The content to be output to the user.
+ */
+declare const debug: (content: Message) => void;
+/**
+ * Outputs a warning message to the user.
+ * Warning messages receive a special formatting to make them stand out in the console.
+ * Note: Warning messages are sent through the standard output.
+ * @param content {string} The content to be output to the user.
+ */
+declare const warn: (content: Message) => void;
+/**
+ * Prints a new line in the terminal.
+ */
+declare const newline: () => void;
+/**
+ * Formats and outputs a fatal error.
+ * Note: This API is not intended to be used internally. If you want to
+ * abort the execution due to an error, raise a fatal error and let the
+ * error handler handle and format it.
+ * @param content {Fatal} The fatal error to be output.
+ */
+declare const error: (content: Fatal) => void;
+declare function stringifyMessage(message: Message): string;
 
 declare const output$1_token: typeof token;
 declare const output$1_content: typeof content;
+type output$1_LogLevel = LogLevel;
+declare const output$1_currentLogLevel: typeof currentLogLevel;
+declare const output$1_shouldOutput: typeof shouldOutput;
+declare const output$1_info: typeof info;
 declare const output$1_success: typeof success;
-declare const output$1_message: typeof message;
+declare const output$1_debug: typeof debug;
+declare const output$1_warn: typeof warn;
+declare const output$1_newline: typeof newline;
 declare const output$1_error: typeof error;
-declare const output$1_warning: typeof warning;
+declare const output$1_stringifyMessage: typeof stringifyMessage;
 declare namespace output$1 {
   export {
     output$1_token as token,
     output$1_content as content,
+    output$1_LogLevel as LogLevel,
+    output$1_currentLogLevel as currentLogLevel,
+    output$1_shouldOutput as shouldOutput,
+    output$1_info as info,
     output$1_success as success,
-    output$1_message as message,
+    output$1_debug as debug,
+    output$1_warn as warn,
+    output$1_newline as newline,
     output$1_error as error,
-    output$1_warning as warning,
+    output$1_stringifyMessage as stringifyMessage,
   };
 }
 
@@ -659,12 +2138,22 @@ declare namespace version {
   };
 }
 
-declare const username: () => Promise<string | null>;
+declare const username: (platform?: typeof platform) => Promise<string | null>;
+/**
+ * Returns the platform and architecture.
+ * @returns {{platform: string, arch: string}} Returns the current platform and architecture.
+ */
+declare const platformAndArch: (platform?: typeof platform) => {
+    platform: string;
+    arch: string;
+};
 
 declare const os_username: typeof username;
+declare const os_platformAndArch: typeof platformAndArch;
 declare namespace os {
   export {
     os_username as username,
+    os_platformAndArch as platformAndArch,
   };
 }
 
@@ -816,18 +2305,52 @@ interface OAuthApplications {
     storefrontRendererApi?: StorefrontRendererAPIOAuthOptions;
     partnersApi?: PartnersAPIOAuthOptions;
 }
+interface OAuthSession {
+    admin?: string;
+    partners?: string;
+    storefront?: string;
+}
+/**
+ * Ensure that we have a valid session to access the Partners API.
+ * If SHOPIFY_CLI_PARTNERS_TOKEN exists, that token will be used to obtain a valid Partners Token
+ * If SHOPIFY_CLI_PARTNERS_TOKEN exists, scopes will be ignored
+ * @param scopes {string[]} Optional array of extra scopes to authenticate with.
+ * @returns {Promise<string>} The access token for the Partners API.
+ */
+declare function ensureAuthenticatedPartners(scopes?: string[], env?: NodeJS.ProcessEnv): Promise<string>;
+/**
+ * Ensure that we have a valid session to access the Storefront API.
+ * @param scopes {string[]} Optional array of extra scopes to authenticate with.
+ * @returns {Promise<string>} The access token for the Storefront API.
+ */
+declare function ensureAuthenticatedStorefront(scopes?: string[]): Promise<string>;
+/**
+ * Ensure that we have a valid Admin session for the given store.
+ * @param store {string} Store fqdn to request auth for
+ * @param scopes {string[]} Optional array of extra scopes to authenticate with.
+ * @returns {Promise<string>} The access token for the Admin API
+ */
+declare function ensureAuthenticatedAdmin(store: string, scopes?: string[]): Promise<string>;
 /**
  * This method ensures that we have a valid session to authenticate against the given applications using the provided scopes.
- * @param options {OAuthApplications} An object containing the applications we need to be authenticated with.
+ * @param applications {OAuthApplications} An object containing the applications we need to be authenticated with.
  * @returns {OAuthSession} An instance with the access tokens organized by application.
  */
-declare function ensureAuthenticated(applications: OAuthApplications): Promise<void>;
+declare function ensureAuthenticated(applications: OAuthApplications, env?: NodeJS.ProcessEnv): Promise<OAuthSession>;
 
 type session_OAuthApplications = OAuthApplications;
+type session_OAuthSession = OAuthSession;
+declare const session_ensureAuthenticatedPartners: typeof ensureAuthenticatedPartners;
+declare const session_ensureAuthenticatedStorefront: typeof ensureAuthenticatedStorefront;
+declare const session_ensureAuthenticatedAdmin: typeof ensureAuthenticatedAdmin;
 declare const session_ensureAuthenticated: typeof ensureAuthenticated;
 declare namespace session {
   export {
     session_OAuthApplications as OAuthApplications,
+    session_OAuthSession as OAuthSession,
+    session_ensureAuthenticatedPartners as ensureAuthenticatedPartners,
+    session_ensureAuthenticatedStorefront as ensureAuthenticatedStorefront,
+    session_ensureAuthenticatedAdmin as ensureAuthenticatedAdmin,
     session_ensureAuthenticated as ensureAuthenticated,
   };
 }
@@ -2158,12 +3681,15 @@ declare namespace schema {
   };
 }
 
-declare function parse(input: string): object;
+declare function decode(input: string): object;
+declare function encode(content: any): string;
 
-declare const toml_parse: typeof parse;
+declare const toml_decode: typeof decode;
+declare const toml_encode: typeof encode;
 declare namespace toml {
   export {
-    toml_parse as parse,
+    toml_decode as decode,
+    toml_encode as encode,
   };
 }
 
@@ -3363,34 +4889,35 @@ declare class Conf<T extends Record<string, any> = Record<string, unknown>> impl
     private _set;
 }
 
-declare const cliKit: Conf<any>;
+interface CachedAppInfo {
+    appId: string;
+    orgId?: string;
+    storeFqdn?: string;
+}
+interface ConfSchema {
+    appInfo: CachedAppInfo[];
+}
+declare const cliKit: Conf<ConfSchema>;
+declare function getAppInfo(appId: string): CachedAppInfo | undefined;
+declare function setAppInfo(appId: string, data: {
+    storeFqdn?: string;
+    orgId?: string;
+}): void;
 
+type store_CachedAppInfo = CachedAppInfo;
 declare const store_cliKit: typeof cliKit;
+declare const store_getAppInfo: typeof getAppInfo;
+declare const store_setAppInfo: typeof setAppInfo;
 declare namespace store {
   export {
+    store_CachedAppInfo as CachedAppInfo,
     store_cliKit as cliKit,
+    store_getAppInfo as getAppInfo,
+    store_setAppInfo as setAppInfo,
   };
 }
 
-/**
- * The schema represents an application token.
- */
-declare const ApplicationTokenSchema: ZodObject<{
-    accessToken: ZodString;
-    expiresAt: ZodEffects<ZodDate, Date, Date>;
-    scopes: ZodArray<ZodString, "many">;
-}, "strip", ZodTypeAny, {
-    accessToken: string;
-    expiresAt: Date;
-    scopes: string[];
-}, {
-    accessToken: string;
-    expiresAt: Date;
-    scopes: string[];
-}>;
-declare type ApplicationToken = TypeOf<typeof ApplicationTokenSchema>;
-
-declare function request$1<T>(query: any, token: ApplicationToken, store: string, variables?: any): Promise<T>;
+declare function request$1<T>(query: any, token: string, store: string, variables?: any): Promise<T>;
 
 declare namespace admin {
   export {
@@ -3398,7 +4925,7 @@ declare namespace admin {
   };
 }
 
-declare function request<T>(query: any, token: ApplicationToken, variables?: any): Promise<T>;
+declare function request<T>(query: any, token: string, variables?: any): Promise<T>;
 
 declare const partners_request: typeof request;
 declare namespace partners {
@@ -3407,15 +4934,111 @@ declare namespace partners {
   };
 }
 
+declare const FindOrganizationQuery: string;
+interface FindOrganizationQuerySchema {
+    organizations: {
+        nodes: {
+            id: string;
+            businessName: string;
+            website: string;
+            stores: {
+                nodes: {
+                    shopId: string;
+                    link: string;
+                    shopDomain: string;
+                    shopName: string;
+                    transferDisabled: boolean;
+                    convertableToPartnerTest: boolean;
+                }[];
+            };
+            apps: {
+                nodes: {
+                    id: string;
+                    title: string;
+                    apiKey: string;
+                    apiSecretKeys: {
+                        secret: string;
+                    };
+                    appType: string;
+                }[];
+            };
+        }[];
+    };
+}
+
+interface AllOrganizationsQuerySchema {
+    organizations: {
+        nodes: {
+            id: string;
+            businessName: string;
+            website: string;
+        }[];
+    };
+}
+declare const AllOrganizationsQuery: string;
+
+declare const CreateAppQuery: string;
+interface CreateAppQueryVariables {
+    org: number;
+    title: string;
+    appUrl: string;
+    redir: string[];
+    type: string;
+}
+interface CreateAppQuerySchema {
+    appCreate: {
+        app: {
+            id: string;
+            apiKey: string;
+            title: string;
+            applicationUrl: string;
+            redirectUrlWhitelist: string[];
+            apiSecretKeys: {
+                secret: string;
+            };
+            appType: string;
+        };
+        userErrors: {
+            field: string[];
+            message: string;
+        }[];
+    };
+}
+
+declare const index_FindOrganizationQuery: typeof FindOrganizationQuery;
+type index_FindOrganizationQuerySchema = FindOrganizationQuerySchema;
+type index_AllOrganizationsQuerySchema = AllOrganizationsQuerySchema;
+declare const index_AllOrganizationsQuery: typeof AllOrganizationsQuery;
+declare const index_CreateAppQuery: typeof CreateAppQuery;
+type index_CreateAppQueryVariables = CreateAppQueryVariables;
+type index_CreateAppQuerySchema = CreateAppQuerySchema;
+declare namespace index {
+  export {
+    index_FindOrganizationQuery as FindOrganizationQuery,
+    index_FindOrganizationQuerySchema as FindOrganizationQuerySchema,
+    index_AllOrganizationsQuerySchema as AllOrganizationsQuerySchema,
+    index_AllOrganizationsQuery as AllOrganizationsQuery,
+    index_CreateAppQuery as CreateAppQuery,
+    index_CreateAppQueryVariables as CreateAppQueryVariables,
+    index_CreateAppQuerySchema as CreateAppQuerySchema,
+  };
+}
+
 declare const api_admin: typeof admin;
 declare const api_partners: typeof partners;
 declare namespace api {
   export {
     api_admin as admin,
     api_partners as partners,
+    index as graphql,
   };
 }
 
+declare const FormData: {
+  new (): FormData;
+  prototype: FormData;
+};
+
 /** @type {typeof globalThis.Blob} */
 declare const Blob: typeof globalThis.Blob;
 
@@ -3619,9 +5242,33 @@ declare namespace http {
   };
 }
 
+declare const InvalidChecksumError: ({ file, expected, got }: {
+    file: string;
+    expected: string;
+    got: string;
+}) => Abort;
+/**
+ * Given a local file and a URL pointing to a remote file representing the MD5 of a local file,
+ * it validates the authenticity of the binary using an MD5 checksum.
+ * @param options: The file to validate and the URL that points to the file containing the MD5.
+ */
+declare function validateMD5({ file, md5FileURL }: {
+    file: string;
+    md5FileURL: string;
+}): Promise<void>;
+
+declare const checksum_InvalidChecksumError: typeof InvalidChecksumError;
+declare const checksum_validateMD5: typeof validateMD5;
+declare namespace checksum {
+  export {
+    checksum_InvalidChecksumError as InvalidChecksumError,
+    checksum_validateMD5 as validateMD5,
+  };
+}
+
 declare const constants: {
     environmentVariables: {
-        debug: string;
+        shopifyConfig: string;
         runAsUser: string;
         partnersEnv: string;
         shopifyEnv: string;
@@ -3631,6 +5278,7 @@ declare const constants: {
         spinWorkspace: string;
         spinNamespace: string;
         spinHost: string;
+        partnersToken: string;
     };
     paths: {
         executables: {
@@ -3658,5 +5306,5 @@ declare const constants: {
     };
 };
 
-export { api, constants, dependency, environment, error$1 as error, file, http, os, output$1 as output, path, schema, session, store, string, system, template, toml, ui, version };
+export { api, checksum, constants, dependency, environment, error$1 as error, file, http, os, output$1 as output, path, schema, session, store, string, system, template, toml, ui, version };
 //# sourceMappingURL=index.d.ts.map