@salesforce/core 4.0.0 → 4.1.0

package/lib/status/streamingClient.js

@@ -13,18 +13,11 @@ const lib_1 = require("@salesforce/kit/lib");
 const lib_2 = require("@salesforce/ts-types/lib");
 const Faye = require("faye");
 const logger_1 = require("../logger");
-const sfdxError_1 = require("../sfdxError");
+const sfError_1 = require("../sfError");
 const messages_1 = require("../messages");
 const types_1 = require("./types");
 Object.defineProperty(exports, "CometClient", { enumerable: true, get: function () { return types_1.CometClient; } });
-messages_1.Messages.importMessagesDirectory(__dirname);
-const messages = messages_1.Messages.load('@salesforce/core', 'streaming', [
-    'waitParamValidValueError',
-    'genericHandshakeTimeout',
-    'invalidApiVersion',
-    'genericTimeout',
-    'handshakeApiVersionError',
-]);
+const messages = new messages_1.Messages('@salesforce/core', 'streaming', new Map([["genericTimeout", "Socket timeout occurred while listening for results."], ["genericHandshakeTimeout", "The streaming request failed to handshake at %s."], ["handshakeApiVersionError", "Invalid API version specified for streaming connection handshake: %s"], ["handshakeApiVersionError.actions", ["Set the API version to match the org as an environment variable (e.g., SFDX_API_VERSION=XX.0)."]], ["waitParamValidValueError", "Invalid value was specified for wait. Please provide a wait value greater than %s minutes."], ["invalidApiVersion", "Invalid api version is being reported by config (apiVersion=%s)."]]));
 /**
  * Validation helper
  *
@@ -151,7 +144,7 @@ class StreamingClient extends lib_1.AsyncOptionalCreatable {
             this.cometClient.setHeader('Authorization', `OAuth ${accessToken}`);
         }
         else {
-            throw new sfdxError_1.SfdxError('Missing or invalid access token', 'MissingOrInvalidAccessToken');
+            throw new sfError_1.SfError('Missing or invalid access token', 'MissingOrInvalidAccessToken');
         }
         this.log(`Streaming client target url: ${this.targetUrl}`);
         this.log(`options.subscribeTimeout (ms): ${this.options.subscribeTimeout.milliseconds}`);
@@ -201,7 +194,7 @@ class StreamingClient extends lib_1.AsyncOptionalCreatable {
      * Subscribe to streaming events. When the streaming processor that's set in the options completes execution it
      * returns a payload in the StatusResult object. The payload is just echoed here for convenience.
      *
-     * **Throws** *{@link SfdxError}{ name: '{@link StreamingClient.TimeoutErrorType.SUBSCRIBE}'}* When the subscribe timeout occurs.
+     * **Throws** *{@link SfError}{ name: '{@link StreamingClient.TimeoutErrorType.SUBSCRIBE}'}* When the subscribe timeout occurs.
      *
      * @param streamInit This function should call the platform apis that result in streaming updates on push topics.
      * {@link StatusResult}
@@ -211,54 +204,52 @@ class StreamingClient extends lib_1.AsyncOptionalCreatable {
         // This outer promise is to hold the streaming promise chain open until the streaming processor
         // says it's complete.
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        return new Promise((subscribeResolve, subscribeReject) => {
-            // This is the inner promise chain that's satisfied when the client impl (Faye/Mock) says it's subscribed.
-            return new Promise((subscriptionResolve, subscriptionReject) => {
-                timeout = setTimeout(() => {
-                    const timeoutError = messages.createError('genericTimeout');
-                    this.doTimeout(timeout, timeoutError);
-                    subscribeReject(timeoutError);
-                }, this.options.subscribeTimeout.milliseconds);
-                // Initialize the subscription.
-                const subscription = this.cometClient.subscribe(this.options.channel, (message) => {
-                    try {
-                        // The result of the stream processor determines the state of the outer promise.
-                        const result = this.options.streamProcessor(message);
-                        // The stream processor says it's complete. Clean up and resolve the outer promise.
-                        if (result && result.completed) {
-                            clearTimeout(timeout);
-                            this.disconnectClient();
-                            subscribeResolve(result.payload);
-                        } // This 'if' is intended to be evaluated until it's completed or until the timeout fires.
-                    }
-                    catch (e) {
-                        // it's completely valid for the stream processor to throw an error. If it does we will
-                        // reject the outer promise. Keep in mind if we are here the subscription was resolved.
+        return new Promise((subscribeResolve, subscribeReject) => 
+        // This is the inner promise chain that's satisfied when the client impl (Faye/Mock) says it's subscribed.
+        new Promise((subscriptionResolve, subscriptionReject) => {
+            timeout = setTimeout(() => {
+                const timeoutError = messages.createError('genericTimeout');
+                this.doTimeout(timeout, timeoutError);
+                subscribeReject(timeoutError);
+            }, this.options.subscribeTimeout.milliseconds);
+            // Initialize the subscription.
+            const subscription = this.cometClient.subscribe(this.options.channel, (message) => {
+                try {
+                    // The result of the stream processor determines the state of the outer promise.
+                    const result = this.options.streamProcessor(message);
+                    // The stream processor says it's complete. Clean up and resolve the outer promise.
+                    if (result?.completed) {
                         clearTimeout(timeout);
                         this.disconnectClient();
-                        subscribeReject(e);
-                    }
-                });
-                subscription.callback(() => {
-                    subscriptionResolve();
-                });
-                subscription.errback((error) => {
-                    subscriptionReject(error);
-                });
-            })
-                .then(() => {
-                // Now that we successfully have a subscription started up we are safe to initialize the function that
-                // will affect the streaming events. I.E. create an org or run apex tests.
-                return streamInit && streamInit();
-            })
-                .catch((error) => {
-                this.disconnect();
-                // Need to catch the subscription rejection or it will result in an unhandled rejection error.
-                clearTimeout(timeout);
-                // No subscription so we can reject the out promise as well.
-                subscribeReject(error);
+                        subscribeResolve(result.payload);
+                    } // This 'if' is intended to be evaluated until it's completed or until the timeout fires.
+                }
+                catch (e) {
+                    // it's completely valid for the stream processor to throw an error. If it does we will
+                    // reject the outer promise. Keep in mind if we are here the subscription was resolved.
+                    clearTimeout(timeout);
+                    this.disconnectClient();
+                    subscribeReject(e);
+                }
             });
-        });
+            subscription.callback(() => {
+                subscriptionResolve();
+            });
+            subscription.errback((error) => {
+                subscriptionReject(error);
+            });
+        })
+            .then(() => 
+        // Now that we successfully have a subscription started up we are safe to initialize the function that
+        // will affect the streaming events. I.E. create an org or run apex tests.
+        streamInit?.())
+            .catch((error) => {
+            this.disconnect();
+            // Need to catch the subscription rejection or it will result in an unhandled rejection error.
+            clearTimeout(timeout);
+            // No subscription so we can reject the out promise as well.
+            subscribeReject(error);
+        }));
     }
     /**
      * Handler for incoming streaming messages.
@@ -296,12 +287,17 @@ class StreamingClient extends lib_1.AsyncOptionalCreatable {
         // unauthenticated connections are being made to salesforce. Let's close the dispatcher if it exists and
         // has no clientId.
         // @ts-ignore
+        // eslint-disable-next-line no-underscore-dangle
         if (this.cometClient._dispatcher) {
             this.log('Closing the faye dispatcher');
             // @ts-ignore
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, no-underscore-dangle
             const dispatcher = this.cometClient._dispatcher;
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, @typescript-eslint/no-unsafe-member-access
             this.log(`dispatcher.clientId: ${dispatcher.clientId}`);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             if (!dispatcher.clientId) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
                 dispatcher.close();
             }
             else {
@@ -342,13 +338,13 @@ exports.StreamingClient = StreamingClient;
                 logger.warn('envDep is deprecated');
             }
             if (!streamProcessor) {
-                throw new sfdxError_1.SfdxError('Missing stream processor', 'MissingArg');
+                throw new sfError_1.SfError('Missing stream processor', 'MissingArg');
             }
             if (!org) {
-                throw new sfdxError_1.SfdxError('Missing org', 'MissingArg');
+                throw new sfError_1.SfError('Missing org', 'MissingArg');
             }
             if (!channel) {
-                throw new sfdxError_1.SfdxError('Missing streaming channel', 'MissingArg');
+                throw new sfError_1.SfError('Missing streaming channel', 'MissingArg');
             }
             this.org = org;
             this.apiVersion = org.getConnection().getApiVersion();
@@ -363,10 +359,9 @@ exports.StreamingClient = StreamingClient;
             this.subscribeTimeout = StreamingClient.DefaultOptions.DEFAULT_SUBSCRIBE_TIMEOUT;
             this.handshakeTimeout = StreamingClient.DefaultOptions.DEFAULT_HANDSHAKE_TIMEOUT;
             this.streamingImpl = {
-                getCometClient: (url) => {
-                    // @ts-ignore
-                    return new Faye.Client(url);
-                },
+                getCometClient: (url) => 
+                // @ts-ignore
+                new Faye.Client(url),
                 setLogger: (logLine) => {
                     // @ts-ignore
                     Faye.logger = {};

package/lib/status/types.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { AnyFunction, AnyJson, JsonMap } from '@salesforce/ts-types';
-export declare type Message = JsonMap;
-export declare type Callback<T = unknown> = (...args: any[]) => T;
+export type Message = JsonMap;
+export type Callback<T = unknown> = (...args: any[]) => T;
 export interface StatusResult {
     /**
      * If the result of the streaming or polling client is expected to return a result

package/lib/testSetup.d.ts

@@ -1,24 +1,26 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import * as sinonType from 'sinon';
+import { SinonSandbox, SinonStatic, SinonStub } from 'sinon';
 import { AnyJson, JsonMap, Optional } from '@salesforce/ts-types';
 import { ConfigContents } from './config/configStore';
+import { Connection } from './org/connection';
 import { Logger } from './logger';
-import { SfdxError } from './sfdxError';
+import { SfError } from './sfError';
 import { CometClient, CometSubscription, Message, StreamingExtension } from './status/streamingClient';
-import { SfOrg } from './globalInfo';
+import { AuthFields, SandboxFields } from './org';
 /**
  * Different parts of the system that are mocked out. They can be restored for
  * individual tests. Test's stubs should always go on the DEFAULT which is exposed
  * on the TestContext.
  */
 export interface SandboxTypes {
-    DEFAULT: sinon.SinonSandbox;
-    CRYPTO: sinon.SinonSandbox;
-    CONFIG: sinon.SinonSandbox;
-    PROJECT: sinon.SinonSandbox;
-    CONNECTION: sinon.SinonSandbox;
-    FS: sinonType.SinonSandbox;
+    DEFAULT: SinonSandbox;
+    CRYPTO: SinonSandbox;
+    CONFIG: SinonSandbox;
+    PROJECT: SinonSandbox;
+    CONNECTION: SinonSandbox;
+    FS: SinonSandbox;
+    ORGS: SinonSandbox;
 }
 /**
  * Different hooks into {@link ConfigFile} used for testing instead of doing file IO.
@@ -52,15 +54,15 @@ export interface ConfigStub {
     updateContents?: () => Promise<JsonMap>;
 }
 /**
- * Different configuration options when running before each
+ * Instantiate a @salesforce/core test context.
  */
-export interface TestContext {
+export declare class TestContext {
     /**
      * The default sandbox is cleared out before each test run.
      *
-     * **See** [sinon sandbox]{@link http://sinonjs.org/releases/v1.17.7/sandbox/}.
+     * **See** [sinon sandbox]{@link https://sinonjs.org/releases/v14/sandbox/}.
      */
-    SANDBOX: sinonType.SinonSandbox;
+    SANDBOX: SinonSandbox;
     /**
      * An object of different sandboxes. Used when
      * needing to restore parts of the system for customized testing.
@@ -74,58 +76,68 @@ export interface TestContext {
      * id A unique id for the test run.
      */
     id: string;
-    /**
-     * A function that returns unique strings.
-     */
-    uniqid: () => string;
     /**
      * An object used in tests that interact with config files.
      */
     configStubs: {
         [configName: string]: Optional<ConfigStub>;
-        GlobalInfo?: ConfigStub;
-        Aliases?: ConfigStub;
-        SfdxProjectJson?: ConfigStub;
-        SfdxConfig?: ConfigStub;
+        AuthInfoConfig?: ConfigStub;
+        Config?: ConfigStub;
+        SfProjectJson?: ConfigStub;
+        TokensConfig?: ConfigStub;
+        OrgUsersConfig?: ConfigStub;
     };
+    /**
+     * A record of stubs created during instantiation.
+     */
+    stubs: Record<string, SinonStub>;
+    constructor(options?: {
+        sinon?: SinonStatic;
+        sandbox?: SinonSandbox;
+        setup?: boolean;
+    });
+    /**
+     * Generate unique string.
+     */
+    uniqid(): string;
     /**
      * A function used when resolving the local path. Calls localPathResolverSync by default.
      *
      * @param uid Unique id.
      */
-    localPathRetriever: (uid: string) => Promise<string>;
+    localPathRetriever(uid: string): Promise<string>;
     /**
      * A function used when resolving the local path.
      *
      * @param uid Unique id.
      */
-    localPathRetrieverSync: (uid: string) => string;
+    localPathRetrieverSync(uid: string): string;
     /**
      * A function used when resolving the global path. Calls globalPathResolverSync by default.
      *
      * @param uid Unique id.
      */
-    globalPathRetriever: (uid: string) => Promise<string>;
+    globalPathRetriever(uid: string): Promise<string>;
     /**
      * A function used when resolving the global path.
      *
      * @param uid Unique id.
      */
-    globalPathRetrieverSync: (uid: string) => string;
+    globalPathRetrieverSync(uid: string): string;
     /**
      * A function used for resolving paths. Calls localPathRetriever and globalPathRetriever.
      *
      * @param isGlobal `true` if the config is global.
      * @param uid user id.
      */
-    rootPathRetriever: (isGlobal: boolean, uid?: string) => Promise<string>;
+    rootPathRetriever(isGlobal: boolean, uid?: string): Promise<string>;
     /**
      * A function used for resolving paths. Calls localPathRetrieverSync and globalPathRetrieverSync.
      *
      * @param isGlobal `true` if the config is global.
      * @param uid user id.
      */
-    rootPathRetrieverSync: (isGlobal: boolean, uid?: string) => string;
+    rootPathRetrieverSync(isGlobal: boolean, uid?: string): string;
     /**
      * Used to mock http request to Salesforce.
      *
@@ -134,7 +146,7 @@ export interface TestContext {
      *
      * **See** {@link Connection.request}
      */
-    fakeConnectionRequest: (request: AnyJson, options?: AnyJson) => Promise<AnyJson>;
+    fakeConnectionRequest(request: AnyJson, options?: AnyJson): Promise<AnyJson>;
     /**
      * Gets a config stub contents by name.
      *
@@ -149,8 +161,62 @@ export interface TestContext {
      * @param value The actual stub contents. The Mock data.
      */
     setConfigStubContents(name: string, value: ConfigContents): void;
-    inProject(inProject: boolean): void;
+    /**
+     * Set stubs for working in the context of a SfProject
+     */
+    inProject(inProject?: boolean): void;
+    /**
+     * Stub salesforce org authorizations.
+     */
+    stubAuths(...orgs: MockTestOrgData[]): Promise<void>;
+    /**
+     * Stub salesforce user authorizations.
+     *
+     * @param users The users to stub.
+     * The key is the username of the admin user and it must be included in the users array in order to obtain the orgId key for the remaining users.
+     * The admin user is excluded from the users array.
+     *
+     */
+    stubUsers(users: Record<string, MockTestOrgData[]>): void;
+    /**
+     * Stub salesforce sandbox authorizations.
+     */
+    stubSandboxes(...sandboxes: MockTestSandboxData[]): Promise<void>;
+    /**
+     * Stub the aliases in the global aliases config file.
+     */
+    stubAliases(aliases: Record<string, string>, group?: string): void;
+    /**
+     * Stub contents in the config file.
+     */
+    stubConfig(config: Record<string, string>): Promise<void>;
+    /**
+     * Stub the tokens in the global token config file.
+     */
+    stubTokens(tokens: Record<string, string>): void;
+    restore(): void;
+    init(): void;
+    /**
+     * Add beforeEach and afterEach hooks to init the stubs and restore them.
+     * This is called automatically when the class is instantiated unless the setup option is set to false.
+     */
+    setup(): void;
+    private requireSinon;
 }
+/**
+ * A function to generate a unique id and return it in the context of a template, if supplied.
+ *
+ * A template is a string that can contain `${%s}` to be replaced with a unique id.
+ * If the template contains the "%s" placeholder, it will be replaced with the unique id otherwise the id will be appended to the template.
+ *
+ * @param options an object with the following properties:
+ * - template: a template string.
+ * - length: the length of the unique id as presented in hexadecimal.
+ */
+export declare function uniqid(options?: {
+    template?: string;
+    length?: number;
+}): string;
 /**
  * Instantiate a @salesforce/core test context. This is automatically created by `const $$ = testSetup()`
  * but is useful if you don't want to have a global stub of @salesforce/core and you want to isolate it to
@@ -163,16 +229,16 @@ export interface TestContext {
  * const $$ = instantiateContext();
  *
  * beforeEach(() => {
- *   stubContext($$);
+ *   $$.init()
  * });
  *
  * afterEach(() => {
- *   restoreContext($$);
+ *   $$.restore();
  * });
  * ```
  * @param sinon
  */
-export declare const instantiateContext: (sinon?: any) => TestContext;
+export declare const instantiateContext: (sinon?: SinonStatic) => TestContext;
 /**
  * Stub a @salesforce/core test context. This will mock out logging to a file, config file reading and writing,
  * local and global path resolution, and http request using connection (soon)*.
@@ -188,16 +254,16 @@ export declare const instantiateContext: (sinon?: any) => TestContext;
  * const $$ = instantiateContext();
  *
  * beforeEach(() => {
- *   stubContext($$);
+ *   $$.init()
  * });
  *
  * afterEach(() => {
- *   restoreContext($$);
+ *   $$.restore();
  * });
  * ```
  * @param testContext
  */
-export declare const stubContext: (testContext: TestContext) => void;
+export declare const stubContext: (testContext: TestContext) => Record<string, SinonStub>;
 /**
  * Restore a @salesforce/core test context. This is automatically stubbed in the global beforeEach created by
  * `const $$ = testSetup()` but is useful if you don't want to have a global stub of @salesforce/core and you
@@ -208,57 +274,28 @@ export declare const stubContext: (testContext: TestContext) => void;
  * const $$ = instantiateContext();
  *
  * beforeEach(() => {
- *   stubContext($$);
+ *   $$.init()
  * });
  *
  * afterEach(() => {
- *   restoreContext($$);
+ *   $$.restore();
  * });
  * ```
  * @param testContext
  */
 export declare const restoreContext: (testContext: TestContext) => void;
-/**
- * Use to mock out different pieces of sfdx-core to make testing easier. This will mock out
- * logging to a file, config file reading and writing, local and global path resolution, and
- * *http request using connection (soon)*.
- *
- * **Note:** The testSetup should be outside of the describe. If you need to stub per test, use
- * `instantiateContext`, `stubContext`, and `restoreContext`.
- * ```
- * // In a mocha tests
- * import testSetup from '@salesforce/core/lib/testSetup';
- *
- * const $$ = testSetup();
- *
- * describe(() => {
- *  it('test', () => {
- *    // Stub out your own method
- *    $$.SANDBOX.stub(MyClass.prototype, 'myMethod').returnsFake(() => {});
- *
- *    // Set the contents that is used when aliases are read. Same for all config files.
- *    $$.configStubs.Aliases = { contents: { 'myTestAlias': 'user@company.com' } };
- *
- *    // Will use the contents set above.
- *    const username = Aliases.fetch('myTestAlias');
- *    expect(username).to.equal('user@company.com');
- *  });
- * });
- * ```
- */
-export declare const testSetup: (sinon?: any) => TestContext;
 /**
  * A pre-canned error for try/catch testing.
  *
  * **See** {@link shouldThrow}
  */
-export declare const unexpectedResult: SfdxError;
+export declare const unexpectedResult: SfError;
 /**
  * Use for this testing pattern:
  * ```
  *  try {
  *      await call()
- *      assert.fail('this should never happen');
+ *      assert.fail("this should never happen");
  *  } catch (e) {
  *  ...
  *  }
@@ -274,7 +311,29 @@ export declare const unexpectedResult: SfdxError;
  *
  * @param f The async function that is expected to throw.
  */
-export declare function shouldThrow(f: Promise<unknown>): Promise<never>;
+export declare function shouldThrow(f: Promise<unknown>, message?: string): Promise<never>;
+/**
+ * Use for this testing pattern:
+ * ```
+ *  try {
+ *      call()
+ *      assert.fail("this should never happen");
+ *  } catch (e) {
+ *  ...
+ *  }
+ *
+ *  Just do this
+ *
+ *  try {
+ *      shouldThrowSync(call); // If this succeeds unexpectedResultError is thrown.
+ *  } catch(e) {
+ *  ...
+ *  }
+ * ```
+ *
+ * @param f The function that is expected to throw.
+ */
+export declare function shouldThrowSync(f: () => unknown, message?: string): never;
 /**
  * A helper to determine if a subscription will use callback or errorback.
  * Enable errback to simulate a subscription failure.
@@ -302,7 +361,7 @@ export interface StreamingMockCometSubscriptionOptions {
     /**
      * If it's an error that states what that error should be.
      */
-    subscriptionErrbackError?: SfdxError;
+    subscriptionErrbackError?: SfError;
     /**
      * A list of messages to playback for the client. One message per process tick.
      */
@@ -372,12 +431,32 @@ export declare class StreamingMockCometClient extends CometClient {
      */
     disconnect(): Promise<void>;
 }
+type MockUserInfo = {
+    Id: string;
+    Username: string;
+    LastName: string;
+    Alias: string;
+    Configs: string[] | undefined;
+    TimeZoneSidKey: string;
+    LocaleSidKey: string;
+    EmailEncodingKey: string;
+    ProfileId: string;
+    LanguageLocaleKey: string;
+    Email: string;
+};
 /**
- * Mock class for OrgData.
+ * Mock class for Salesforce Orgs.
+ *
+ * @example
+ * ```
+ * const testOrg = new MockTestOrgData();
+ * await $$.stubAuths(testOrg)
+ * ```
  */
 export declare class MockTestOrgData {
     testId: string;
-    alias?: string;
+    aliases?: string[];
+    configs?: string[];
     username: string;
     devHubUsername?: string;
     orgId: string;
@@ -387,15 +466,65 @@ export declare class MockTestOrgData {
     clientSecret: string;
     authcode: string;
     accessToken: string;
-    refreshToken: string;
+    refreshToken: string | undefined;
+    tracksSource: boolean | undefined;
     userId: string;
     redirectUri: string;
+    isDevHub?: boolean;
+    isScratchOrg?: boolean;
+    isExpired?: boolean | 'unknown';
+    password?: string;
     constructor(id?: string, options?: {
         username: string;
     });
+    /**
+     * Add devhub username to properties.
+     */
     createDevHubUsername(username: string): void;
+    /**
+     * Mark this org as a devhub.
+     */
     makeDevHub(): void;
+    /**
+     * Returns a MockTestOrgData that represents a user created in the org.
+     */
     createUser(user: string): MockTestOrgData;
-    getMockUserInfo(): JsonMap;
-    getConfig(): Promise<SfOrg>;
+    /**
+     * Return mock user information based on this org.
+     */
+    getMockUserInfo(): MockUserInfo;
+    /**
+     * Return the auth config file contents.
+     */
+    getConfig(): Promise<AuthFields>;
+    /**
+     * Return the Connection for the org.
+     */
+    getConnection(): Promise<Connection>;
+}
+/**
+ * Mock class for Salesforce Sandboxes.
+ *
+ * @example
+ * ```
+ * const testOrg = new MockTestSandboxData();
+ * await $$.stubSandboxes(testOrg)
+ * ```
+ */
+export declare class MockTestSandboxData {
+    id: string;
+    sandboxOrgId: string;
+    prodOrgUsername: string;
+    sandboxName?: string;
+    username?: string;
+    constructor(id?: string, options?: Partial<{
+        prodOrgUsername: string;
+        name: string;
+        username: string;
+    }>);
+    /**
+     * Return the auth config file contents.
+     */
+    getConfig(): Promise<SandboxFields>;
 }
+export {};