@salesforce/core 3.13.1 → 3.15.1

package/lib/globalInfo/accessors/sandboxAccessor.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxAccessor = void 0;
+const types_1 = require("../types");
+class SandboxAccessor {
+    constructor(globalInfo) {
+        this.globalInfo = globalInfo;
+    }
+    /**
+     * Returns all the sandboxes (or all the sandboxes for a given prod org)
+     *
+     * @param entity entity as a string should be a production org username
+     * and when entity is a SfSandbox, the prod org entity.prodOrgUsername will
+     * used in the filter.
+     */
+    getAll(entity) {
+        const all = this.globalInfo.get(types_1.SfInfoKeys.SANDBOXES) || {};
+        if (!entity) {
+            return all;
+        }
+        const prodOrgUsername = typeof entity === 'string' ? entity : entity.prodOrgUsername;
+        return Object.fromEntries(Object.entries(all).filter(([, value]) => value.prodOrgUsername === prodOrgUsername));
+    }
+    /**
+     * Returns the SfSandbox config entry that corresponds to the given
+     * sandbox org id if it exists
+     *
+     * @param sandboxOrgId the sandboxOrgId that corresponds to a sandbox
+     */
+    get(sandboxOrgId) {
+        var _a;
+        return sandboxOrgId ? (_a = this.getAll()[sandboxOrgId]) !== null && _a !== void 0 ? _a : null : null;
+    }
+    /**
+     * Returns true if the given sandbox org id exists
+     *
+     * @param sandboxOrgId the sandboxOrgId that corresponds to a sandbox
+     */
+    has(sandboxOrgId) {
+        var _a;
+        return !!(sandboxOrgId ? (_a = this.getAll()[sandboxOrgId]) !== null && _a !== void 0 ? _a : null : null);
+    }
+    /**
+     * Set an sandboxOrgId for the given sandbox entity
+     *
+     * @param sandboxOrgId the sandboxOrgId you want to set
+     * @param entity the sandbox entity
+     */
+    set(sandboxOrgId, entity) {
+        this.globalInfo.set(`${types_1.SfInfoKeys.SANDBOXES}["${sandboxOrgId}"]`, entity);
+    }
+    unset(sandboxOrgId) {
+        delete this.globalInfo.get(types_1.SfInfoKeys.SANDBOXES)[sandboxOrgId];
+    }
+}
+exports.SandboxAccessor = SandboxAccessor;
+//# sourceMappingURL=sandboxAccessor.js.map

package/lib/globalInfo/globalInfoConfig.d.ts

@@ -5,6 +5,7 @@ import { OrgAccessor } from './accessors/orgAccessor';
 import { TokenAccessor } from './accessors/tokenAccessor';
 import { AliasAccessor } from './accessors/aliasAccessor';
 import { SfInfo } from './types';
+import { SandboxAccessor } from './accessors/sandboxAccessor';
 export declare function deepCopy<T extends AnyJson>(data: T): T;
 export declare class GlobalInfo extends ConfigFile<ConfigFile.Options, SfInfo> {
     protected static encryptedKeys: RegExp[];
@@ -27,6 +28,7 @@ export declare class GlobalInfo extends ConfigFile<ConfigFile.Options, SfInfo> {
     get orgs(): OrgAccessor;
     get tokens(): TokenAccessor;
     get aliases(): AliasAccessor;
+    get sandboxes(): SandboxAccessor;
     set(key: string, value: ConfigValue): void;
     write(newContents?: SfInfo): Promise<SfInfo>;
     protected init(): Promise<void>;

package/lib/globalInfo/globalInfoConfig.js

@@ -15,6 +15,7 @@ const orgAccessor_1 = require("./accessors/orgAccessor");
 const tokenAccessor_1 = require("./accessors/tokenAccessor");
 const aliasAccessor_1 = require("./accessors/aliasAccessor");
 const types_1 = require("./types");
+const sandboxAccessor_1 = require("./accessors/sandboxAccessor");
 function deepCopy(data) {
     return JSON.parse(JSON.stringify(data));
 }
@@ -64,6 +65,9 @@ class GlobalInfo extends configFile_1.ConfigFile {
     get aliases() {
         return new aliasAccessor_1.AliasAccessor(this);
     }
+    get sandboxes() {
+        return new sandboxAccessor_1.SandboxAccessor(this);
+    }
     set(key, value) {
         if ((0, ts_types_1.isPlainObject)(value)) {
             value = this.timestamp(value);
@@ -101,5 +105,6 @@ GlobalInfo.EMPTY_DATA_MODEL = {
     [types_1.SfInfoKeys.ORGS]: {},
     [types_1.SfInfoKeys.TOKENS]: {},
     [types_1.SfInfoKeys.ALIASES]: {},
+    [types_1.SfInfoKeys.SANDBOXES]: {},
 };
 //# sourceMappingURL=globalInfoConfig.js.map

package/lib/globalInfo/sfdxDataHandler.d.ts

@@ -1,5 +1,5 @@
 import { ConfigFile } from '../config/configFile';
-import { SfInfo, SfInfoKeys, SfOrg, SfOrgs } from './types';
+import { SfInfo, SfInfoKeys, SfOrg, SfOrgs, SfSandbox } from './types';
 interface Handler<T extends SfInfoKeys> {
     sfKey: T;
     merge: (sfData: SfInfo) => Promise<Partial<SfInfo>>;
@@ -11,7 +11,7 @@ interface Changes<T> {
     deleted: string[];
 }
 export declare class SfdxDataHandler {
-    handlers: (AuthHandler | AliasesHandler)[];
+    handlers: (AuthHandler | AliasesHandler | SandboxesHandler)[];
     private original;
     write(latest?: SfInfo): Promise<void>;
     merge(sfData?: SfInfo): Promise<SfInfo>;
@@ -40,4 +40,14 @@ export declare class AliasesHandler extends BaseHandler<SfInfoKeys.ALIASES> {
     merge(sfData?: SfInfo): Promise<Partial<SfInfo>>;
     write(latest: SfInfo): Promise<void>;
 }
+export declare class SandboxesHandler extends BaseHandler<SfInfoKeys.SANDBOXES> {
+    private static sandboxFilenameFilterRegEx;
+    sfKey: typeof SfInfoKeys.SANDBOXES;
+    merge(sfData?: SfInfo): Promise<Partial<SfInfo>>;
+    migrate(): Promise<Pick<SfInfo, SfInfoKeys.SANDBOXES>>;
+    write(latest: SfInfo, original: SfInfo): Promise<void>;
+    listAllSandboxFiles(): Promise<string[]>;
+    listAllSandboxes(): Promise<SfSandbox[]>;
+    private findChanges;
+}
 export {};

package/lib/globalInfo/sfdxDataHandler.js

@@ -6,13 +6,14 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AliasesHandler = exports.AuthHandler = exports.SfdxDataHandler = void 0;
+exports.SandboxesHandler = exports.AliasesHandler = exports.AuthHandler = exports.SfdxDataHandler = void 0;
 const path_1 = require("path");
 const fs = require("fs");
 const kit_1 = require("@salesforce/kit");
 const ts_types_1 = require("@salesforce/ts-types");
 const global_1 = require("../global");
 const configFile_1 = require("../config/configFile");
+const sandboxOrgConfig_1 = require("../config/sandboxOrgConfig");
 const globalInfoConfig_1 = require("./globalInfoConfig");
 const types_1 = require("./types");
 function isEqual(object1, object2) {
@@ -28,7 +29,7 @@ function isEqual(object1, object2) {
 }
 class SfdxDataHandler {
     constructor() {
-        this.handlers = [new AuthHandler(), new AliasesHandler()];
+        this.handlers = [new AuthHandler(), new AliasesHandler(), new SandboxesHandler()];
     }
     async write(latest = globalInfoConfig_1.GlobalInfo.emptyDataModel) {
         await Promise.all(this.handlers.map((handler) => handler.write(latest, this.original)));
@@ -65,13 +66,13 @@ class BaseHandler {
             });
             (0, kit_1.set)(merged, `${key}["${k}"]`, Object.assign({}, older, newer));
         }
-        // Keys that exist in .sfdx but not .sf are added becase we assume
+        // Keys that exist in .sfdx but not .sf are added because we assume
         // that this means the key was created using sfdx.
         // However, this is not always a valid assumption because it could
         // also mean that the key was deleted using sf, in which case we
         // do not want to migrate the sfdx key to sf.
         // Programmatically differentiating between a new key and a deleted key
-        // would be nearly impossible. Instead we should ensure that whenever
+        // would be nearly impossible. Instead, we should ensure that whenever
         // sf deletes a key it also deletes it in sfdx. This way, we can safely
         // assume that we should migrate any keys that exist in in .sfdx
         const unhandledSfdxKeys = sfdxKeys.filter((k) => !sfKeys.includes(k));
@@ -211,4 +212,98 @@ class AliasesHandler extends BaseHandler {
 }
 exports.AliasesHandler = AliasesHandler;
 AliasesHandler.SFDX_ALIASES_FILENAME = 'alias.json';
+class SandboxesHandler extends BaseHandler {
+    constructor() {
+        super(...arguments);
+        this.sfKey = types_1.SfInfoKeys.SANDBOXES;
+    }
+    async merge(sfData = globalInfoConfig_1.GlobalInfo.emptyDataModel) {
+        var _a, _b;
+        const sfdxData = await this.migrate();
+        const merged = (0, globalInfoConfig_1.deepCopy)(sfData);
+        // Only merge the key this handler is responsible for.
+        const key = this.sfKey;
+        const sfKeys = Object.keys((_a = sfData[key]) !== null && _a !== void 0 ? _a : {});
+        const sfdxKeys = Object.keys((_b = sfdxData[key]) !== null && _b !== void 0 ? _b : {});
+        // sandbox entries for .sf and .sfdx contain static data. Given there
+        // can be no mutation during the life of the sandbox, having to merge common keys
+        // is unnecessary.
+        // Keys that exist in .sfdx but not .sf are added because we assume
+        // that this means the key was created using sfdx.
+        // However, this is not always a valid assumption because it could
+        // also mean that the key was deleted using sf, in which case we
+        // do not want to migrate the sfdx key to sf.
+        // Programmatically differentiating between a new key and a deleted key
+        // would be nearly impossible. Instead, we should ensure that whenever
+        // sf deletes a key it also deletes it in sfdx. This way, we can safely
+        // assume that we should migrate any keys that exist in .sfdx
+        const unhandledSfdxKeys = sfdxKeys.filter((k) => !sfKeys.includes(k));
+        for (const k of unhandledSfdxKeys) {
+            (0, kit_1.set)(merged, `${key}["${k}"]`, sfdxData[key][k]);
+        }
+        // Keys that exist in .sf but not .sfdx are deleted because we assume
+        // that this means the key was deleted while using sfdx.
+        // We can make this assumption because keys that are created by sf will
+        // always be migrated back to sfdx
+        const unhandledSfKeys = sfKeys.filter((k) => !sfdxKeys.includes(k));
+        for (const k of unhandledSfKeys) {
+            delete merged[key][k];
+        }
+        return merged;
+    }
+    async migrate() {
+        const oldSandboxes = await this.listAllSandboxes();
+        const newSandboxes = Object.fromEntries(oldSandboxes.map((old) => [old.sandboxOrgId, old]));
+        return { [this.sfKey]: newSandboxes };
+    }
+    async write(latest, original) {
+        const { changed, deleted } = await this.findChanges(latest, original);
+        for (const sandboxData of Object.values(changed)) {
+            if (sandboxData) {
+                const orgId = sandboxData.sandboxOrgId;
+                const sandboxConfig = new sandboxOrgConfig_1.SandboxOrgConfig(sandboxOrgConfig_1.SandboxOrgConfig.getOptions(orgId));
+                sandboxConfig.set(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME, sandboxData.prodOrgUsername);
+                await sandboxConfig.write();
+            }
+        }
+        for (const username of deleted) {
+            const originalSandbox = original.sandboxes[username];
+            const orgId = originalSandbox.sandboxOrgId;
+            const sandboxConfig = new sandboxOrgConfig_1.SandboxOrgConfig(sandboxOrgConfig_1.SandboxOrgConfig.getOptions(orgId));
+            await sandboxConfig.unlink();
+        }
+    }
+    async listAllSandboxFiles() {
+        const globalFiles = await fs.promises.readdir(global_1.Global.SFDX_DIR);
+        return globalFiles.filter((file) => file.match(SandboxesHandler.sandboxFilenameFilterRegEx));
+    }
+    async listAllSandboxes() {
+        return Promise.all((await this.listAllSandboxFiles()).map(async (filename) => {
+            const matches = filename.match(SandboxesHandler.sandboxFilenameFilterRegEx);
+            const orgId = matches ? matches[1] : '';
+            const sandboxConfig = new sandboxOrgConfig_1.SandboxOrgConfig(sandboxOrgConfig_1.SandboxOrgConfig.getOptions(orgId));
+            const stat = await sandboxConfig.stat();
+            const contents = { ...(await sandboxConfig.read(true)), sandboxOrgId: orgId };
+            const sandbox = Object.assign(contents, { timestamp: stat.mtime.toISOString() });
+            return sandbox;
+        }));
+    }
+    async findChanges(latest, original) {
+        var _a;
+        const latestSandboxes = latest.sandboxes;
+        const originalSandboxes = original.sandboxes;
+        const changed = {};
+        for (const [sandboxOrgId, sandbox] of Object.entries(latestSandboxes)) {
+            const originalSandbox = (_a = originalSandboxes[sandboxOrgId]) !== null && _a !== void 0 ? _a : {};
+            if (!isEqual(sandbox, originalSandbox)) {
+                changed[sandboxOrgId] = sandbox;
+            }
+        }
+        const deleted = Object.keys(originalSandboxes).filter((sandboxOrgId) => !latestSandboxes[sandboxOrgId]);
+        return { changed, deleted };
+    }
+}
+exports.SandboxesHandler = SandboxesHandler;
+// The regular expression that filters files stored in $HOME/.sfdx
+SandboxesHandler.sandboxFilenameFilterRegEx = /^(00D.*?)\.sandbox\.json$/;
 //# sourceMappingURL=sfdxDataHandler.js.map

package/lib/globalInfo/types.d.ts

@@ -2,7 +2,8 @@ import { JsonMap } from '@salesforce/ts-types';
 export declare enum SfInfoKeys {
     ORGS = "orgs",
     TOKENS = "tokens",
-    ALIASES = "aliases"
+    ALIASES = "aliases",
+    SANDBOXES = "sandboxes"
 }
 export declare type Timestamp = {
     timestamp: string;
@@ -32,8 +33,25 @@ export interface SfTokens {
 export interface SfAliases {
     [alias: string]: string;
 }
+export declare type SfSandbox = {
+    sandboxOrgId: string;
+    prodOrgUsername: string;
+    sandboxName?: string;
+    sandboxUsername?: string;
+    sandboxProcessId?: string;
+    sandboxInfoId?: string;
+} & Timestamp & SfEntry;
+/**
+ * The key will always be the sandbox username and the value will always be the
+ * production org username
+ * { "user@salesforce.com.mysandbox": "user@salesforce.com" }
+ */
+export interface SfSandboxes {
+    [sandboxOrgId: string]: SfSandbox;
+}
 export declare type SfInfo = {
     [SfInfoKeys.ORGS]: SfOrgs;
     [SfInfoKeys.TOKENS]: SfTokens;
     [SfInfoKeys.ALIASES]: SfAliases;
+    [SfInfoKeys.SANDBOXES]: SfSandboxes;
 };

package/lib/globalInfo/types.js

@@ -6,5 +6,6 @@ var SfInfoKeys;
     SfInfoKeys["ORGS"] = "orgs";
     SfInfoKeys["TOKENS"] = "tokens";
     SfInfoKeys["ALIASES"] = "aliases";
+    SfInfoKeys["SANDBOXES"] = "sandboxes";
 })(SfInfoKeys = exports.SfInfoKeys || (exports.SfInfoKeys = {}));
 //# sourceMappingURL=types.js.map

package/lib/org/authInfo.d.ts

@@ -46,6 +46,7 @@ export declare type OrgAuthorization = {
     configs: Nullable<string[]>;
     isScratchOrg?: boolean;
     isDevHub?: boolean;
+    isSandbox?: boolean;
     instanceUrl?: string;
     accessToken?: string;
     error?: string;
@@ -60,7 +61,7 @@ export interface AccessTokenOptions {
     instanceUrl?: string;
 }
 export declare type AuthSideEffects = {
-    alias: string;
+    alias?: string;
     setDefault: boolean;
     setDefaultDevHub: boolean;
 };

package/lib/org/authInfo.js

@@ -130,7 +130,7 @@ class AuthInfo extends kit_1.AsyncOptionalCreatable {
      * @returns {string}
      */
     static getDefaultInstanceUrl() {
-        const configuredInstanceUrl = configAggregator_1.ConfigAggregator.getValue('instanceUrl').value;
+        const configuredInstanceUrl = configAggregator_1.ConfigAggregator.getValue(orgConfigProperties_1.OrgConfigProperties.ORG_INSTANCE_URL).value;
         return configuredInstanceUrl || sfdcUrl_1.SfdcUrl.PRODUCTION;
     }
     /**
@@ -166,6 +166,7 @@ class AuthInfo extends kit_1.AsyncOptionalCreatable {
                     instanceUrl,
                     isScratchOrg: Boolean(devHubUsername),
                     isDevHub: isDevHub || false,
+                    isSandbox: globalInfo.sandboxes.has(orgId),
                     orgId: orgId,
                     accessToken: authInfo.getConnectionOptions().accessToken,
                     oauthMethod: authInfo.isJwt() ? 'jwt' : authInfo.isOauth() ? 'web' : 'token',

package/lib/org/connection.js

@@ -86,7 +86,7 @@ class Connection extends jsforce_1.Connection {
         if (!baseOptions.version) {
             // Set the API version obtained from the config aggregator.
             const configAggregator = options.configAggregator || (await configAggregator_1.ConfigAggregator.create());
-            baseOptions.version = (0, ts_types_1.asString)(configAggregator.getInfo('apiVersion').value);
+            baseOptions.version = (0, ts_types_1.asString)(configAggregator.getInfo('org-api-version').value);
         }
         const providedOptions = options.authInfo.getConnectionOptions();
         // Get connection options from auth info and create a new jsForce connection
@@ -102,7 +102,7 @@ class Connection extends jsforce_1.Connection {
                 }
             }
             else {
-                conn.logger.debug(`The apiVersion ${baseOptions.version} was found from ${((_b = options.connectionOptions) === null || _b === void 0 ? void 0 : _b.version) ? 'passed in options' : 'config'}`);
+                conn.logger.debug(`The org-api-version ${baseOptions.version} was found from ${((_b = options.connectionOptions) === null || _b === void 0 ? void 0 : _b.version) ? 'passed in options' : 'config'}`);
             }
         }
         catch (err) {
@@ -334,7 +334,7 @@ class Connection extends jsforce_1.Connection {
     async autoFetchQuery(soql, queryOptions = {}) {
         const config = await configAggregator_1.ConfigAggregator.create();
         // take the limit from the calling function, then the config, then default 10,000
-        const maxFetch = config.getInfo('maxQueryLimit').value || queryOptions.maxFetch || 10000;
+        const maxFetch = config.getInfo('org-max-query-limit').value || queryOptions.maxFetch || 10000;
         const options = Object.assign(queryOptions, {
             autoFetch: true,
             maxFetch,
@@ -418,7 +418,7 @@ class Connection extends jsforce_1.Connection {
             // so get the latest.
             await useLatest();
         }
-        this.logger.debug(`Loaded latest apiVersion ${version}`);
+        this.logger.debug(`Loaded latest org-api-version ${version}`);
         return version;
     }
 }

package/lib/org/org.d.ts

@@ -1,8 +1,8 @@
 import { AsyncOptionalCreatable, Duration } from '@salesforce/kit';
-import { AnyJson, JsonMap, Optional } from '@salesforce/ts-types';
+import { AnyJson, JsonMap, Nullable, Optional } from '@salesforce/ts-types';
 import { ConfigAggregator } from '../config/configAggregator';
 import { OrgUsersConfig } from '../config/orgUsersConfig';
-import { SandboxOrgConfig } from '../config/sandboxOrgConfig';
+import { SfSandbox } from '../globalInfo';
 import { Connection } from './connection';
 import { AuthFields, AuthInfo } from './authInfo';
 import { ScratchOrgCreateOptions, ScratchOrgCreateResult } from './scratchOrgCreate';
@@ -20,7 +20,7 @@ export declare enum OrgTypes {
 export interface StatusEvent {
     sandboxProcessObj: SandboxProcessObject;
     interval: number;
-    retries: number;
+    remainingWait: number;
     waitingOnAuth: boolean;
 }
 export interface ResultEvent {
@@ -36,7 +36,8 @@ export declare enum SandboxEvents {
     EVENT_STATUS = "status",
     EVENT_ASYNC_RESULT = "asyncResult",
     EVENT_RESULT = "result",
-    EVENT_AUTH = "auth"
+    EVENT_AUTH = "auth",
+    EVENT_RESUME = "resume"
 }
 export interface SandboxUserAuthResponse {
     authUserName: string;
@@ -44,7 +45,7 @@ export interface SandboxUserAuthResponse {
     instanceUrl: string;
     loginUrl: string;
 }
-export interface SandboxProcessObject {
+export declare type SandboxProcessObject = {
     Id: string;
     Status: string;
     SandboxName: string;
@@ -57,13 +58,17 @@ export interface SandboxProcessObject {
     Description?: string;
     ApexClassId?: string;
     EndDate?: string;
-}
+};
 export declare type SandboxRequest = {
     SandboxName: string;
     LicenseType?: string;
     SourceId?: string;
     Description?: string;
 };
+export declare type ResumeSandboxRequest = {
+    SandboxName?: string;
+    SandboxProcessObjId?: string;
+};
 export declare type ScratchOrgRequest = Pick<ScratchOrgCreateOptions, 'connectedAppConsumerKey' | 'durationDays' | 'nonamespace' | 'noancestors' | 'wait' | 'retry' | 'apiversion' | 'definitionjson' | 'definitionfile' | 'orgConfig' | 'clientSecret'>;
 /**
  * Provides a way to manage a locally authenticated Org.
@@ -109,9 +114,23 @@ export declare class Org extends AsyncOptionalCreatable<Org.Options> {
      * @param sandboxReq SandboxRequest options to create the sandbox with
      * @param options Wait: The amount of time to wait before timing out, Interval: The time interval between polling
      */
-    createSandbox(sandboxReq: SandboxRequest, options: {
+    createSandbox(sandboxReq: SandboxRequest, options?: {
+        wait?: Duration;
+        interval?: Duration;
+        async?: boolean;
+    }): Promise<SandboxProcessObject>;
+    /**
+     * resume a sandbox creation from a production org
+     * 'this' needs to be a production org with sandbox licenses available
+     *
+     * @param resumeSandboxRequest SandboxRequest options to create the sandbox with
+     * @param options Wait: The amount of time to wait (default: 30 minutes) before timing out,
+     * Interval: The time interval (default: 30 seconds) between polling
+     */
+    resumeSandbox(resumeSandboxRequest: ResumeSandboxRequest, options?: {
         wait?: Duration;
         interval?: Duration;
+        async?: boolean;
     }): Promise<SandboxProcessObject>;
     /**
      * Creates a scratchOrg
@@ -133,9 +152,7 @@ export declare class Org extends AsyncOptionalCreatable<Org.Options> {
      */
     retrieveOrgUsersConfig(): Promise<OrgUsersConfig>;
     /**
-     * Removes the scratch org config file at $HOME/.sfdx/[name].json, any project level org
-     * files, all user auth files for the org, matching default config settings, and any
-     * matching aliases.
+     * Cleans up all org related artifacts including users, sandbox config(if a sandbox and auth file.
      *
      * @param throwWhenRemoveFails Determines if the call should throw an error or fail silently.
      */
@@ -259,17 +276,18 @@ export declare class Org extends AsyncOptionalCreatable<Org.Options> {
      */
     removeUsername(auth: AuthInfo | string): Promise<Org>;
     /**
-     * Sets the key/value pair in the sandbox config for this org. For convenience `this` object is returned.
+     * set the sandbox config related to this given org
      *
-     *
-     * @param {key} The key for this value
-     * @param {value} The value to save
+     * @param orgId {string} orgId of the sandbox
+     * @param config {SfSandbox} config of the sandbox
      */
-    setSandboxOrgConfigField(field: SandboxOrgConfig.Fields, value: string): Promise<Org>;
+    setSandboxConfig(orgId: string, config: SfSandbox): Promise<Org>;
     /**
-     * Returns an org config field. Returns undefined if the field is not set or invalid.
+     * get the sandbox config for the given orgId
+     *
+     * @param orgId {string} orgId of the sandbox
      */
-    getSandboxOrgConfigField(field: SandboxOrgConfig.Fields): Promise<any>;
+    getSandboxConfig(orgId: string): Promise<Nullable<SfSandbox>>;
     /**
      * Retrieves the highest api version that is supported by the target server instance. If the apiVersion configured for
      * Sfdx is greater than the one returned in this call an api version mismatch occurs. In the case of the CLI that
@@ -300,6 +318,28 @@ export declare class Org extends AsyncOptionalCreatable<Org.Options> {
      * Returns the JSForce connection for the org.
      */
     getConnection(): Connection;
+    supportsSourceTracking(): Promise<boolean>;
+    /**
+     * query SandboxProcess via sandbox name
+     *
+     * @param name SandboxName to query for
+     * @private
+     */
+    querySandboxProcessBySandboxName(name: string): Promise<SandboxProcessObject>;
+    /**
+     * query SandboxProcess via SandboxInfoId
+     *
+     * @param id SandboxInfoId to query for
+     * @private
+     */
+    querySandboxProcessBySandboxInfoId(id: string): Promise<SandboxProcessObject>;
+    /**
+     * query SandboxProcess via Id
+     *
+     * @param id SandboxProcessId to query for
+     * @private
+     */
+    querySandboxProcessById(id: string): Promise<SandboxProcessObject>;
     /**
      * Initialize async components.
      */
@@ -334,10 +374,6 @@ export declare class Org extends AsyncOptionalCreatable<Org.Options> {
      * Deletes the users config file
      */
     private removeUsersConfig;
-    /**
-     * @ignore
-     */
-    private retrieveSandboxOrgConfig;
     private manageDelete;
     /**
      * Remove the org users auth file.
@@ -345,38 +381,24 @@ export declare class Org extends AsyncOptionalCreatable<Org.Options> {
      * @param throwWhenRemoveFails true if manageDelete should throw or not if the deleted fails.
      */
     private removeUsers;
-    /**
-     * Remove an associate sandbox config.
-     *
-     * @param throwWhenRemoveFails true if manageDelete should throw or not if the deleted fails.
-     */
     private removeSandboxConfig;
     private writeSandboxAuthFile;
-    /**
-     * Polls for the new sandbox to be created - and will write the associated auth files
-     *
-     * @private
-     * @param options
-     *  sandboxProcessObj: The in-progress sandbox signup request
-     *  retries: the number of retries to poll for every 30s
-     *  shouldPoll: wait for polling, or just return
-     *  pollInterval: Duration to sleep between poll events, default 30 seconds
-     */
     private pollStatusAndAuth;
     /**
-     * query SandboxProcess via SandboxInfoId
+     * query SandboxProcess using supplied where clause
      *
-     * @param id SandboxInfoId to query for
+     * @param where clause to query for
      * @private
      */
     private querySandboxProcess;
     /**
      * determines if the sandbox has successfully been created
      *
-     * @param sandboxProcessObj sandbox signup progeress
+     * @param sandboxProcessObj sandbox signup progress
      * @private
      */
     private sandboxSignupComplete;
+    private validateWaitOptions;
 }
 export declare namespace Org {
     /**