@mongodb-js/compass-web 0.20.1 → 0.21.0

package/dist/compass-web.d.ts

@@ -0,0 +1,1638 @@
+import { default as React_2 } from 'react';
+
+/**
+ * Valid statuses for activeOrLaunchedExperimentsToStatus
+ */
+declare enum ActiveOrLaunchedStatus {
+    LIVE = "LIVE",
+    COOLDOWN = "COOLDOWN",
+    LAUNCHED = "LAUNCHED"
+}
+
+/**
+ * Represents additional options for ExperimentSDK.addExistingExperimentData
+ */
+declare type AddExistingExperimentDataOptions<LoggerTeam> = BasicFunctionOptions<LoggerTeam>;
+
+/**
+ * Object parameter for ExperimentSDK.addExperimentCalls, which is a dev-env-only function
+ */
+declare interface AddExperimentCallsProps<T extends TypeData> {
+    assignmentCalls?: Partial<Record<T['experimentName'], Promise<AsyncStatus>>>;
+    allocationPointCalls?: Partial<Record<T['allocationPointName'], Promise<AsyncStatus>>>;
+}
+
+export declare type AllPreferences = UserPreferences & CliOnlyPreferences & NonUserPreferences & PermanentFeatureFlags;
+
+declare type AnyWorkspace = WelcomeWorkspace | MyQueriesWorkspace | DataModelingWorkspace | ShellWorkspace | ServerStatsWorkspace | DatabasesWorkspace | CollectionsWorkspace | CollectionWorkspace;
+
+/**
+ * Represents additional options for ExperimentSDK.assignByPoints
+ * Right now it's aliased to the "AssignOptions" interface because the same options apply for this function.
+ * However, in the future if the 2 option interfaces diverge, feel free to define this as its own
+ * distinct interface.
+ */
+declare type AssignByPointsOptions<LoggerTeam> = BasicAPICallingFunctionOptions<LoggerTeam> & {
+    /**
+     * Set to true to use the entity generic mmsAssignByPointsV3 api method
+     *
+     * @default undefined which will use the deprecated mmsAssignByPoints api function instead when unspecified
+     *
+     * @todo remove this property after the deprecated mmsAssignByPoints api function is removed.
+     *  Once the deprecated function is removed, by default all assignByPoints requests should be using v3.
+     */
+    useV3Assignment?: boolean;
+};
+
+declare type AssignExperimentFn = (experimentName: ExperimentTestName, options?: types.AssignOptions<string>) => Promise<types.AsyncStatus | null>;
+
+/**
+ * Entity assignment data. Used in {@link SDKAssignment}, {@link SDKGhostAssignment}, and {@link SDKGenericAssignment}
+ */
+declare interface AssignmentData<ExperimentVariantName> {
+    /**
+     * Represents if the entity has been allocated into the experiment. Should ALWAYS be used
+     * to check if an entity is allocated in an experiment--just checking for the presence of the experiment name key
+     * in SDK state isn't enough.
+     */
+    isInSample: boolean;
+    /**
+     * If the entity is allocated, the variant name they are assigned to.
+     * Can be null if they are not allocated in the experiment.
+     */
+    variant: ExperimentVariantName | null;
+}
+
+declare type AssignmentsMap<T extends TypeData> = Partial<Record<T['experimentName'], SDKAssignment<T['experimentName'], T['experimentVariantName']>>>;
+
+/**
+ * Represents additional options for ExperimentSDK.assign
+ */
+declare type AssignOptions<LoggerTeam> = BasicAPICallingFunctionOptions<LoggerTeam> & {
+    /**
+     * Specify the entity type to use with the new entity generic mmsAssignV3 api function
+     *
+     * @default undefined which will use the deprecated mmsAssign api function instead when unspecified
+     *
+     * @todo make this property required after the deprecated mmsAssign api function is removed.
+     *  Once the deprecated function is removed, by default all assign requests will require an entity type
+     */
+    entityTypeForV3Assignment?: EntityType;
+};
+
+/**
+ * A simple object representing the status of a response from an async call
+ */
+declare interface AsyncStatus {
+    statusCode: StatusCode;
+    message?: string;
+}
+
+/**
+ * Atlas metadata for clusters, refer to the backend implementation to see how
+ * the values are derived
+ *
+ * https://github.com/10gen/mms/blob/1efe59a9bb4646635d946d979e5c9f4423f95b10/server/src/main/com/xgen/svc/mms/res/view/explorer/DataExplorerConnectionInfoView.java#L223-L302
+ */
+export declare interface AtlasClusterMetadata {
+    /**
+     * Atlas organization id
+     */
+    orgId: string;
+    /**
+     * Project ID that uniquely identifies an Atlas project. Legacy name is
+     * "groupId" as projects were previously identified as "groups".
+     *
+     * https://www.mongodb.com/docs/atlas/api/atlas-admin-api-ref/#project-id
+     */
+    projectId: string;
+    /**
+     * Unique id returned with the clusterDescription
+     */
+    clusterUniqueId: string;
+    /**
+     * Cluster name, unique inside same project
+     */
+    clusterName: string;
+    /**
+     * Possible types of Atlas clusters.
+     *
+     * https://github.com/10gen/mms/blob/9e6bf2d81d4d85b5ac68a15bf471dcddc5922323/client/packages/types/nds/clusterDescription.ts#L12-L16
+     */
+    clusterType: 'REPLICASET' | 'SHARDED' | 'GEOSHARDED';
+    /**
+     * Cluster states
+     *
+     * `DELETED` is never returned from backend, but can be derived by connection
+     * missing when polling connection info list
+     */
+    clusterState: 'CREATING' | 'UPDATING' | 'PAUSED' | 'IDLE' | 'REPAIRING' | 'DELETING' | 'DELETED';
+    /**
+     * A special id and type that are only relevant in context of mms metrics
+     * features. These are deployment items props (with a special exception for
+     * serverless, where id is just name, and type is `serverless` that doesn't
+     * make sense in context of deployments), not cluster description props.
+
+     * https://github.com/10gen/mms/blob/43b0049a85196b44e465feb9b96ef942d6f2c8f4/client/js/legacy/core/models/deployment
+     */
+    metricsId: string;
+    /**
+     * Somewhat related to the clusterType provided as part of clusterDescription,
+     * but accounting for special shared cluster types. Used for `/metrics/*`
+     * routing and automation agent jobs
+     *
+     *   - `cluster`:    any sharded cluster type (sharded or geo sharded /
+     *                   "global writes" one)
+     *   - `replicaSet`: anything that is not sharded (both dedicated or "free
+     *                   tier" / MTM)
+     *   - `serverless`: specifically for serverless clusters
+     *   - `flex`:       new type that replaces serverless and some shared
+     *                   clusters
+     */
+    metricsType: 'replicaSet' | 'cluster' | 'serverless' | 'flex';
+    /**
+     * Atlas API base url to be used when making control plane requests for a
+     * regionalized cluster. Always `null` while compass-web is disabled for
+     * those types of clusters
+     */
+    regionalBaseUrl: null;
+    instanceSize?: string;
+    /**
+     * Flags indicating Atlas cluster-level control plane feature support
+     */
+    supports: {
+        /**
+         * True if cluster is geo sharded and not self managed
+         */
+        globalWrites: boolean;
+        /**
+         * True for dedicated clusters
+         */
+        rollingIndexes: boolean;
+    };
+}
+
+declare type AtlasOrgPreferences = {
+    enableGenAIFeaturesAtlasOrg: boolean;
+};
+
+declare type AtlasProjectPreferences = {
+    enableGenAIFeaturesAtlasProject: boolean;
+    enableGenAISampleDocumentPassingOnAtlasProject: boolean;
+};
+
+declare interface BasicAPICallingFunctionOptions<LoggerTeam> extends BasicFunctionOptions<LoggerTeam> {
+    /**
+     * An API timeout value, in milliseconds
+     * (if not passed, a default value of 5 seconds is used)
+     */
+    timeoutMs?: number;
+}
+
+/**
+ * Shared props that all functions can provide in their "options" objects
+ */
+declare interface BasicFunctionOptions<LoggerTeam> {
+    /**
+     * The "team" value that should be used for the logger
+     * (if not passed, the "defaultTeam" from initialization is used)
+     */
+    team?: LoggerTeam;
+}
+
+/**
+ * A standard response object from a hook with async calls.
+ */
+declare interface BasicHookResponse {
+    asyncStatus: HookAsyncStatus | null;
+    error: Error | null;
+}
+
+declare type CliOnlyPreferences = {
+    exportConnections?: string;
+    importConnections?: string;
+    passphrase?: string;
+    version?: boolean;
+    versions?: boolean;
+    help?: boolean;
+    showExampleConfig?: boolean;
+    trustedConnectionString?: boolean;
+};
+
+declare type CollectionSubtab = 'Documents' | 'Aggregations' | 'Schema' | 'Indexes' | 'Validation' | 'GlobalWrites';
+
+declare type CollectionsWorkspace = {
+    type: 'Collections';
+    connectionId: string;
+    namespace: string;
+    inferredFromPrivileges?: boolean;
+};
+
+export declare type CollectionTabInfo = {
+    isTimeSeries: boolean;
+    isReadonly: boolean;
+    sourceName?: string | null;
+    inferredFromPrivileges: boolean;
+};
+
+declare type CollectionWorkspace = {
+    tabId: string;
+    type: 'Collection';
+    connectionId: string;
+    namespace: string;
+    subTab: CollectionSubtab;
+    initialQuery?: unknown;
+    initialPipeline?: unknown[];
+    initialPipelineText?: string;
+    initialAggregation?: unknown;
+    editViewName?: string;
+    inferredFromPrivileges?: boolean;
+};
+
+export declare const CompassExperimentationProvider: React_2.FC<{
+    children: React_2.ReactNode;
+    useAssignment: UseAssignmentHook;
+    assignExperiment: AssignExperimentFn;
+}>;
+
+/** @public */
+export declare const CompassWeb: ({ appName, orgId, projectId, darkMode, initialAutoconnectId, initialWorkspace, onActiveWorkspaceTabChange, initialPreferences, onLog, onDebug, onTrack, onOpenConnectViaModal, onFailToLoadConnections, }: CompassWebProps) => React_2.JSX.Element;
+
+/** @public */
+export declare type CompassWebProps = {
+    /**
+     * App name to be passed with the connection string when connection to a
+     * cluster (default: "Compass Web")
+     */
+    appName?: string;
+    /**
+     * Atlas Cloud organization id
+     */
+    orgId: string;
+    /**
+     * Atlas Cloud project id (sometimes called group id)
+     */
+    projectId: string;
+    /**
+     * Whether or not darkMode should be active for the app
+     */
+    darkMode?: boolean;
+    /**
+     * Optional. If passed, compass-web will try to find connection info with that
+     * id in connection storage and pass it as autoconnect info to the
+     * compass-connections
+     */
+    initialAutoconnectId?: string;
+    /**
+     * Optional. If passed, compass-web will open provided workspace right away.
+     * If workspace requires active connection, the connectionId from the
+     * workspace will be used for the autoconnect info getter. In that case
+     * connectionId from the workspace takes precedence over
+     * `initialAutoconnectId`
+     */
+    initialWorkspace?: OpenWorkspaceOptions;
+    /**
+     * Callback prop called when current active workspace changes. Can be used to
+     * communicate current workspace back to the parent component for example to
+     * sync router with the current active workspace
+     */
+    onActiveWorkspaceTabChange<WS extends WorkspaceTab>(ws: WS | null, collectionInfo: WS extends {
+        type: 'Collection';
+    } ? CollectionTabInfo | null : never): void;
+    /**
+     * Set of initial preferences to override default values
+     */
+    initialPreferences?: Partial<AllPreferences>;
+    /**
+     * Callback prop called every time any code inside Compass logs something
+     */
+    onLog?: LogFunction;
+    /**
+     * Callback prop called every time any code inside Compass prints a debug
+     * statement
+     */
+    onDebug?: DebugFunction;
+    /**
+     * Callback prop called for every track event inside Compass
+     */
+    onTrack?: TrackFunction;
+    /**
+     * Callback prop that will be called with atlas metadata for a certain cluster
+     * when the action is selected from the sidebar actions. Should be used to
+     * show the Atlas Cloud "Connect" modal
+     */
+    onOpenConnectViaModal?: (atlasMetadata?: AtlasClusterMetadata) => void;
+    /**
+     * Callback prop called when connections fail to load
+     */
+    onFailToLoadConnections: (err: Error) => void;
+};
+
+/**
+ * Options to pass into the constructor
+ */
+declare interface ConstructorOptions<T extends TypeData> {
+    /** The entityId(s). Required. */
+    entityIds: EntityIds;
+    /** The environment the SDK is running in. Required. */
+    environment: Environment;
+    /** Logger-related properties */
+    loggerOptions?: LoggerOptions<T['loggerTeam']>;
+    /** Tracker-related properties */
+    trackerOptions?: TrackerOptions<T['experimentViewedProps']>;
+}
+
+declare type DatabasesWorkspace = {
+    type: 'Databases';
+    connectionId: string;
+};
+
+declare type DataModelingWorkspace = {
+    type: 'Data Modeling';
+};
+
+/** @public */
+export declare type DebugFunction = (...args: any[]) => void;
+
+/**
+ * A set of ID values. Each ID is treated as a distinct entity for experiments.
+ * Experiment configuration dictates which entity ID it will use for allocation.
+ */
+declare interface EntityIds {
+    /**
+     * All values below are strings representing an entity ID.
+     * Each of these should be serializeable to an "ObjectId",
+     * which is Mongodb's default ID class for a document.
+     * @example
+     * "621509aae911cb2e37ba91ca"
+     */
+    orgId?: string;
+    groupId?: string;
+    userId?: string;
+    hostId?: string;
+    clusterId?: string;
+    tenantId?: string;
+}
+
+/**
+ * The different Entity units for experiments
+ */
+declare enum EntityType {
+    USER = "USER",
+    GROUP = "GROUP",
+    ORG = "ORG",
+    HOST = "HOST",
+    CLUSTER = "CLUSTER",
+    TENANT = "TENANT"
+}
+
+/**
+ * The different values of "environment" in the SDK
+ * This is used for, among other things, determining the root URL for backend calls
+ */
+declare enum Environment {
+    LOCAL = "local",
+    E2E = "e2e",
+    DEMOBOX = "demobox",
+    DEV = "dev",
+    QA = "qa",
+    PROD = "prod"
+}
+
+/**
+ * Object parameter for ExperimentSDK.addExistingExperimentData
+ */
+declare interface ExistingData<T extends TypeData> {
+    assignments?: ServerAssignments<T>;
+    experimentAttributes?: ServerExperimentAttributeMap<T>;
+    ghostAssignments?: Array<ServerGhostAssignment<T['experimentName'], T['experimentVariantName']>>;
+    activeOrLaunchedExperimentsToStatus?: Partial<Record<T['experimentName'], ActiveOrLaunchedStatus>>;
+    allocationPointsToLiveOrLaunchedExperiments?: Partial<Record<T['allocationPointName'], Array<T['experimentName']>>>;
+}
+
+/**
+ * Represents the types an Experiment Attribute in an experiment configuration can be.
+ */
+declare type ExperimentAttributeValue = string | boolean | number;
+
+/** Class providing MDB Experiment SDK functionality */
+declare class ExperimentSDK<T extends TypeData> {
+    #private;
+    /**
+     * @description
+     * Create an instance of the SDK. It's highly recommended to pass in a type interface
+     * as well for stronger typing of experiment data and log properties.
+     *
+     * Intended usage:
+     * Called by the ExperimentSDKClient class in index.ts. Should never be called directly by a user.
+     *
+     * @param {ConstructorOptions} options - Required
+     *
+     * @return {ExperimentSDK} An instance of the class
+     *
+     * @throws Can throw an error if entityIds, loggerOptions, or trackerOptions are invalid.
+     *
+     * @example
+     * const options: ConstructorOptions = {
+     *  entityIds: { orgId: 'iAmAnOrgId' },
+     *  environment: Environment.DEV,
+     * };
+     *
+     * enum ExperimentName {
+     *  EXP_ONE = 'expOne',
+     * };
+     *
+     * enum ExperimentVariantName {
+     *  EXP_VARIANT_ONE = 'expVariantOne',
+     * };
+     *
+     * enum ExperimentAttributeName {
+     *  SHOW_LEFT_NAV_LINK = 'showLeftNavLink',
+     * };
+     *
+     * enum AllocationPointName {
+     *  CLUSTER_CARD_PAGE = 'CLUSTER_CARD_PAGE',
+     * };
+     *
+     * enum LoggerTeam {
+     *  Team1 = 'Team 1',
+     * };
+     *
+     * interface Types {
+     *  experimentName: ExperimentName,
+     *  experimentVariantName: ExperimentVariantName,
+     *  experimentAttributeName: ExperimentAttributeName,
+     *  allocationPointName: AllocationPointName,
+     *  loggerTeam: LoggerTeam,
+     * }
+     *
+     * const experimentSDK = new ExperimentSDK<Types>(options);
+     */
+    constructor(options: ConstructorOptions<T>);
+    /**
+     * @description
+     * Retrieves non-experiment-data-related properties of the SDK. Returns deep clones of the props.
+     *
+     * Intended usage:
+     * Primarily for debugging and testing purposes. Not intended to allow mutating the instance props.
+     *
+     * @return
+     * An object containing copies of selected properties of the SDK:
+     * entityIds, loggerOptions, trackerOptions, and environment
+     *
+     * @example
+     * const res = sdk.getProperties();
+     * console.log(res);
+     * {
+     entityIds: { orgId: 'iAmAnOrgId', groupId: 'iAmAGroupId', userId: 'iAmAUserId' },
+     loggerOptions: { logger: { log: [Function: log] }, defaultTeam: LoggerTeam.Team1 },
+     trackerOptions: { tracker: { track: [Function: track] } },
+     environment: 'dev'
+     }
+     *
+     */
+    getProperties(): Readonly<GetPropertiesResponse<T>>;
+    /**
+     * @description
+     * If the updated entityIds are different from the existing entityIds, update the existing entityIds
+     * and clear assignmentsMap,experimentAttributesMap, assignmentCalls, allocationPointCalls.
+     * If the updated entityIds are the same, then no changes are made
+     *
+     * Intended usage:
+     * Updates the existing entityIds and clears existing experiment data
+     *
+     * @return The SDK itself
+     *
+     * @throws Can throw an error if the entityIds are invalid
+     *
+     * @example
+     * const updatedEntities =  { orgId: 'iAmAnOrgId', groupId: 'iAmAGroupId', userId: 'iAmAUserId' };
+     * const res = sdk.updateEntityIds(updatedEntities);
+     * const newSdkIds = res.getProperties().entityIds;
+     * console.log(newSdkIds);
+     * { orgId: 'iAmAnOrgId', groupId: 'iAmAGroupId', userId: 'iAmAUserId' }
+     */
+    updateEntityIds(entities: EntityIds): ExperimentSDK<T>;
+    /**
+     * @description Updates loggerOptions on the SDK
+     *
+     * Intended usage:
+     * Updates the logger options for logging within the SDK
+     *
+     * @param {LoggerOptions} loggerOptions - Required
+     *
+     * @return {SdkInstance} An instance of the class
+     *
+     * @throws Can throw an error if the loggerOptions are invalid.
+     *
+     * @example
+     * enum LoggerTeam {
+     *  Team1 = 'Test Team 1',
+     * };
+     *
+     * const updatedSDK = sdk.updateLoggerOptions({
+     *  logger: loggerClient, // In MMS, this will be bugsnag
+     *  defaultTeam: LoggerTeam.Team1
+     * })
+     *
+     * const newSdkLoggerOptions = res.getProperties().loggerOptions;
+     * console.log(newSdkLoggerOptions);
+     * { logger: loggerClient, defaultTeam: LoggerTeam.Team1 }
+     */
+    updateLoggerOptions(loggerOptions: LoggerOptions<T['loggerTeam']>): this;
+    /**
+     * @description
+     * Update the Tracker object that makes analytics calls
+     *
+     * Intended usage:
+     * Updates the Tracker object that makes analytics calls if it needs to be changed,
+     * or set if it was not set during initialization
+     *
+     * @param {TrackerOptions} trackerOptions - Required
+     *
+     * @return {SdkInstance} An instance of the class
+     *
+     * @throws Can throw an error if the trackerOptions are invalid.
+     *
+     * @example
+     * const newTracker =  { track: () => {}}; // In MMS, this will be Heliotrope
+     * const newTrackerOptions = { tracker: newTracker };
+     * const newSdkTrackerOptions = experimentSdk.getProperties().trackerOptions;
+     * console.log(newSdkTrackerOptions);
+     * { tracker: { track: () => {} } }
+     */
+    updateTrackerOptions(trackerOptions: TrackerOptions<T['experimentViewedProps']>): ExperimentSDK<T>;
+    /**
+     * @description
+     * Allows passing in existing experiment data (such as assignments, experiment attributes,
+     * ghost assignments, activeOrLaunchedExperimentsToStatus, and allocationPointsToLiveOrLaunchedExperiments)
+     * to populate the SDK state.
+     *
+     * This function
+     * - Checks if existing assignments, ghost assignments, or experiment attributes for the entity are
+     *   attempting to be overwritten and if so, logs a warning and prioritizes the SDK's existing data.
+     * - Takes care of transforming "string" experiment attribute values into numbers and booleans as needed.
+     * - Loads in any experiment overrides provided by the FEdEx (go/fedex; Front End Experiment Editor)
+     *   experiment editor extension. This behavior is only activated when the extension is active and
+     *   writing overrides to sessionStorage.
+     * - If provided, ingests the activeOrLaunchedExperimentsToStatus and allocationPointsToLiveOrLaunchedExperiments
+     *   maps to the SDK state in order to prevent unnecessary network requests for experiments (eg. only make Get
+     *   assignment calls for Active or Launched experiments; only make assign calls for Live or Launched).
+     *
+     * Intended usage:
+     * Useful if the client has data about the state of experiments or an entity's assignments from another
+     * data store (such as the MMS "params" call) that it would like to make the SDK aware of
+     *
+     * @param {ExistingData} existingData - Required. Object with optional assignments,
+     * experimentAttributes, ghostAssignments, activeOrLaunchedExperimentsToStatus, and
+     * allocationPointsToLiveOrLaunchedExperiments properties.
+     * @param {AddExistingExperimentDataOptions} options - Optional. Object with additional optional props,
+     * such as a "team" override for logging purposes.
+     *
+     * @return {SdkInstance} An instance of the class
+     *
+     * @example
+     * // ex 1: passing in full existingData object
+     * const { assignments, experimentAttributes, ghostAssignments } = clientApi.fetchExistingData(); // an external api
+     * experimentSdk.addExistingExperimentData({assignments, experimentAttributes, ghostAssignments },
+     * { team: LoggerTeam.Team1 });
+     *
+     * // ex 2: passing in an assignment
+     * const existingServerAssignment = {
+     *   assignmentDate: '1658340252128',
+     *   entityId: '621509aae911cb2e37ba91ca',
+     *   entityType: 'ORG',
+     *   id: '62d8439c9ce6473793cff6ca',
+     *   tag: 'activation',
+     *   testId: '62bb810b61be7d017fcc2198',
+     *   testName: 'expOne',
+     *   testGroupId: 'variantOne,
+     *   testGroupDatabaseId: '62bb810b61be7d017fcc2196',
+     * };
+     *
+     * experimentSdk.addExistingExperimentData({
+     *  assignments: [existingServerAssignment]
+     * });
+     *
+     * // ex 3: passing in an experiment attribute
+     * const existingAttribute = {
+     *  showLeftNavLink: 'false',
+     * };
+     *
+     * experimentSdk.addExistingExperimentData({
+     *  experimentAttributes: existingAttribute,
+     * });
+     */
+    addExistingExperimentData(existingData: Readonly<ExistingData<T>>, options?: AddExistingExperimentDataOptions<T['loggerTeam']>): ExperimentSDK<T>;
+    /**
+     * @description
+     * Allows user to pass in a function to be called with all assignments, whenever the #assignmentsMap is updated.
+     *
+     * Intended usage:
+     * Allows for pubsub access to experiment assignments. Subscribers will have access to a clone of the assignment data.
+     *
+     * @param {function} subscriberCallback - Required. Function that will be called with {@link AssignmentsMap}, whenever
+     * a new assignment occurs.
+     *
+     * @return A function that can be called to unsubscribe from #assignmentsMap updates.
+     *
+     * @example
+     * const subscriptionCb = (assignmentsMap) => {
+     *    console.log('AB test AssignmentsMap has changed', assignmentsMap)
+     * };
+     *
+     * const unsubscribe = subscribeToAssignmentsMap(subscriptionCb);
+     *
+     * await sdk.assign(ExperimentName.EXP_ONE);
+     * // subscriptionCb will execute here, displaying the console log with the updated assignmentsMap.
+     *
+     * unsubscribe();
+     *
+     * await sdk.assign(ExperimentName.EXP_TWO);
+     * // subscriptionCb will not execute here, as the subscription has been removed.
+     *
+     */
+    subscribeToAssignmentsMap(subscriberCallback: (assignmentsMap: AssignmentsMap<T>) => void): () => void;
+    /**
+     * @description
+     * Retrieves assignment data for a particular experiment name. This function will wait for the assign
+     * and assignByPoints function to finish retrieving data and return the assignment, or a Promise that
+     * resolves with null if entity is not in the experiment. If assignment data for an experiment name has not been
+     * or is not being retrieved by the assign or assignByPoints function, this function will make a GET request to MMS
+     * backend to get the assignment.
+     * If no assignment is found, this function will return a promise that resolves with null.
+     * If activeOrLaunchedExperimentsToStatus has been initialized, skips making network requests for experiments that
+     * are not in the map (active or LAUNCHED).
+     *
+     * When waiting for allocation point calls to resolve:
+     * - If allocationPointsToLiveOrLaunchedExperiments is not initialized, waits for all allocation point calls
+     * - If allocationPointsToLiveOrLaunchedExperiments is initialized, only waits for allocation point calls
+     *   that are used by this experiment (i.e., the experiment name is in the array for that allocation point)
+     *
+     * If trackIsInSample (parameter of function) is set to true and the entity is in the experiment sample,
+     * trackIsInSample() will be called, which fires an Experiment Viewed event with default props and
+     * trackIsInSampleCustomProps (part of the 'options' parameter of this function).
+     *
+     * If there is an error, this function will log a warning and return a promise that resolves with null.
+     * (It will not throw an error.)
+     *
+     * This is the ONLY function in the SDK that retrieves experiment data.
+     *
+     * Intended usage:
+     * Used to get an entity's assignment information for an experiment.
+     *
+     * @param {ExperimentName} experimentName - Required
+     * @param {boolean} trackIsInSample - Required
+     * @param {GetAssignmentOptions} options - Optional. User of this function can pass in an optional
+     * customProps object if they want the Experiment Viewed event to have custom properties and/or pass in a team
+     * if they want the logger to log for a specific team
+     *
+     * @return A Promise that resolves to either an {@link SDKAssignment} object or null (if the assignment info does not
+     * exist, because entity is not in experiment, data has not been fetched, or the pending assignment call errored out).
+     * Even if the Promise resolves to an SDKAssignment object, the entity may not be in the experiment
+     * --check {@link SDKAssignment.assignmentData.isInSample} to be sure.
+     *
+     * @example
+     * const experimentName: ExperimentName = ExperimentName.EXP_ONE;
+     * const getAssignmentOptions: GetAssignmentOptions<Types> = {
+     trackIsInSampleCustomProps:{
+     firstProperty: 1,
+     secondProperty: '2',
+     },
+     team: 'Team 1',
+     }
+     * const res: SDKAssignment<Types['experimentName'], Types['experimentVariantName']> | null =
+     *                                               await sdk.getAssignment(experimentName, false, getAssignmentOptions);
+     * console.log(res);
+     *  {
+     assignmentData: { isInSample: true, variant: 'expVariantOne' },
+     experimentData: {
+     assignmentDate: '1658340252128',
+     entityId: '621509aae911cb2e37ba91ca',
+     entityType: 'ORG',
+     id: '62d8439c9ce6473793cff6ca',
+     tag: 'activation',
+     testId: '62bb810b61be7d017fcc2198',
+     testName: 'expOne',
+     testGroupId: 'expVariantOne',
+     testGroupDatabaseId: '62bb810b61be7d017fcc2196'
+     }
+     }
+     *
+     */
+    getAssignment(experimentName: T['experimentName'], trackIsInSample: boolean, options?: GetAssignmentOptions<T>): Promise<SDKAssignment<T['experimentName'], T['experimentVariantName']> | null>;
+    /**
+     * @description
+     * DO NOT USE!
+     * Gets a stored assignment object for a given experiment name.
+     * This is only meant to be used by internal tools! In real world applications,
+     * you should always use the async getAssignment function, to ensure that a cache miss is
+     * never misinterpreted as a null assignment.
+     * @param {T['experimentName']} experimentName The name of the experiment
+     * @return The assignment object if it exists in the cache, or null if not
+     */
+    unsafe_getCachedAssignment(experimentName: T['experimentName']): SDKAssignment<T['experimentName'], T['experimentVariantName']> | null;
+    /**
+     * @description
+     * Given an experiment attribute name and a fallback value, returns the value for attributeName from the
+     * local SDK state experimentAttributesMap, or the fallback value if none exists
+     *
+     * Intended usage:
+     * To retrieve experiment attributes.
+     *
+     * @param attributeName - Required. The attribute name.
+     * @param {ExperimentAttributeValue} fallbackValue - Required. The fallback value to be returned if attributeName does
+     * not exist in local SDK state experimentAttributesMap.
+     *
+     * @return An ExperimentAttributeValue for attributeName or fallbackValue if none exists.
+     *
+     * @example
+     * const attr: ExperimentAttributeValue = sdk.getExperimentAttribute(
+     *   ExperimentAttributeName.SHOW_LEFT_NAV_LINK,
+     *   false
+     * );
+     * console.log(attr);
+     * // true
+     */
+    getExperimentAttribute(attributeName: T['experimentAttributeName'], fallbackValue: ExperimentAttributeValue): ExperimentAttributeValue;
+    /**
+     * @description
+     * Given an experiment name, returns a Promise that is successfully resolved if the experiment is
+     * successfully assigned, via the API if needed, for the SDK entity.
+     *
+     * If the API call has an error during assignment, this function should log the error message
+     * and return a rejected Promise with the error. In these cases, the function will "clean up" the errored API call
+     * so that the assignment can be reattempted by another "assign" call later if the user wishes.
+     *
+     * If there is an existing Promise for the experiment, the function will not make an API call and will return
+     * the existing Promise. If there is no existing Promise but the assignment or ghost assignment already exists,
+     * the function will not make an API call and a resolved Promise will be returned.
+     * If the activeOrLaunchedExperimentsToStatus map has been initialized and the experiment is in not in the map
+     * as LIVE or LAUNCHED, skips making a network request to assign.
+     *
+     * CAN make a POST API call.
+     * (For more information on the POST API call, see the
+     * [wiki](https://wiki.corp.mongodb.com/display/MMS/MDB+Experiment+JS+SDK+Usage))
+     *
+     * Does NOT return assignment information--users should use the getAssignment function for that.
+     *
+     * Intended usage:
+     * Assign the SDK entity for an experiment.
+     * Can only take 1 experiment name per call. (If you are looking to pass multiple experiment names in 1 call,
+     * perhaps that means this experiment allocation point should be a reusable allocation point.)
+     *
+     * @param experimentName - Required. An experiment name string.
+     * @param {AssignOptions} options - Optional. Object with additional optional props, such as a "team" override
+     * for logging purposes and a timeoutMs prop to define the API timeout.
+     *
+     * @return A Promise that resolves to an AsyncStatus object. If the Promise resolves, the AsyncStatus
+     * object should represent success. In case of error, the Promise will reject.
+     *
+     * @throws Can throw an error if the API call throws an error.
+     *
+     * @example
+     * const experimentName: ExperimentName = ExperimentName.EXP_ONE;
+     *
+     * const options: AssignOptions<Types['loggerTeam']> = {
+     *  team: LoggerOptions.Team1,
+     * };
+     *
+     * try {
+     *  await sdk.assign(experimentName, options);
+     * } catch (e) {
+     *  // error handling in case the promise rejects. In this case, assume
+     *  // the assignment data is not available in the SDK. Can retry, bubble up the error, etc.
+     * }
+     *
+     * // at this point, can assume assignment info for this experiment is in the SDK so can retrieve the assignment
+     * const assignment: SDKAssignment<Types['experimentName'], Types['experimentVariantName']> | null =
+     *  await sdk.getAssignment(
+     *    ExperimentName.EXP_ONE,
+     *    true,
+     *    options as GetAssignmentOptions<Types>
+     *  );
+     * // see getAssignment documentation for more details on using that function
+     */
+    assign(experimentName: T['experimentName'], options?: AssignOptions<T['loggerTeam']>): Promise<AsyncStatus>;
+    /**
+     * @description
+     * Given an array of allocation point names, returns a Promise that is successfully resolved if all the experiments
+     * associated with the given points are successfully assigned via the API for the SDK entity.
+     * If ANY of the points in the given array is NOT successfully assigned, this function should log the error message
+     * and return a rejected Promise with the error. In these cases, the function will "clean up" the errored API call
+     * so that the point assignment can be reattempted by another "assignByPoints" call later if the user wishes.
+     * If a point was previously successfully assigned or if the promise is currently pending,
+     * the function will not make another API call for that point and will use the existing Promise for that point.
+     * If allocationPointsToLiveOrLaunchedExperiments is initialized, it will not make API calls for points that do not
+     * map to at least 1 experiment.
+     *
+     * CAN make a POST API call.
+     * (For more information on the POST API call, see the
+     * [wiki](https://wiki.corp.mongodb.com/display/MMS/MDB+Experiment+JS+SDK+Usage))
+     *
+     * Does NOT return assignment information--users should use the getAssignment function for that.
+     *
+     * Intended usage:
+     * Assign entities for experiments configured to use reusable allocation points.
+     * Can take multiple points in 1 request.
+     *
+     * @param allocationPoints - Required. An array of allocation point name strings.
+     * @param {AssignByPointsOptions} options - Optional. Object with additional optional props, such as a "team" override
+     * for logging purposes and a timeoutMs prop to define the API timeout.
+     *
+     * @return A Promise that resolves to an array of AsyncStatus objects. If the Promise resolves, all the AsyncStatus
+     * objects should represent success. In case of error, the Promise will reject.
+     *
+     * @throws Can throw an error if the API call throws an error.
+     *
+     * @example
+     * const allocationPointsArray: Array<AllocationPointName> = [
+     *  AllocationPointName.CLUSTER_CARD_PAGE,
+     *  AllocationPointName.REGISTRATION_SUCCESS_PAGE,
+     * ];
+     *
+     * const options: AssignByPointsOptions<Types['loggerTeam']> = {
+     *  team: LoggerTeam.Team1,
+     * };
+     *
+     * try {
+     *  await sdk.assignByPoints(allocationPointsArray, options);
+     * } catch (e) {
+     *  // error handling in case the promise rejects. In this case, assume
+     *  // the assignment data is not available in the SDK. Can retry, bubble up the error, etc.
+     * }
+     *
+     * // at this point, can assume assignment information for those points is in the SDK so can retrieve assignments
+     * const assignment: SDKAssignment<Types['experimentName'], Types['experimentVariantName']> | null =
+     *  await sdk.getAssignment(
+     *    'experiment_that_was_allocated_with_allocation_points',
+     *    true,
+     *    options as GetAssignmentOptions<Types>
+     *  );
+     * // see getAssignment documentation for more details on using that function
+     */
+    assignByPoints(allocationPoints: Array<T['allocationPointName']>, options?: AssignByPointsOptions<T['loggerTeam']>): Promise<Array<AsyncStatus>>;
+    /**
+     * @description
+     * Submits an "Experiment Viewed" or "Experiment GhostViewed" event with the client's tracker (if any).
+     * Sends through default props ({@link ExperimentViewedBaseEvent}) and any custom props defined.
+     * Will wait for relevant pending assignment calls to resolve to get assignment data.
+     * (If there is an error, will log it but try to continue.) If there isn't a tracker or if
+     * the assignment data or assignment call doesn't exist, it will log a warning and result in a no-op.
+     *
+     * Any error encountered in the client's track call will be bubbled up.
+     *
+     * Intended usage:
+     * Fires the "Experiment Viewed" event using the client's tracker, if the client tracker
+     * has been initialized and the entity is in the experiment, OR
+     * Fires the "Experiment GhostViewed" event using the client's tracker, if the client tracker
+     * has been initialized and the entity is in an Experiment Holdout but has a ghost assignment
+     * for the experiment.
+     *
+     * @param {ExperimentName} experimentName - Required
+     * @param {Object} customProps - Optional. User of this function can pass in an optional
+     * customProps object if they want the Experiment Viewed/GhostViewed event to have custom
+     * properties in addition to the default experiment props ({@link ExperimentViewedBaseEvent})
+     *
+     * @return {Promise<AsyncStatus|null>}
+     * If there is a no op, returns a Promise that resolves with null.
+     * Else if there is an error with the client's track call, throws an error.
+     * Else if there is no error and track was called successfully, returns a Promise
+     * that resolves with a 2XX code.
+     *
+     * @throws Can throw an error if the registered Tracker's track function throws an error.
+     *
+     * @example
+     * const experimentName = "experimentNameExample";
+     * const customProps =  { property1: true, property2: 0 };
+     * const res: <AsyncStatus | null> = await sdk.trackIsInSample(experimentName, customProps);
+     * if(res?.statusCode === 200) {
+     *   console.log("track call succeeded");
+     * }
+     */
+    trackIsInSample(experimentName: T['experimentName'], customProps?: T['experimentViewedProps'], team?: string): Promise<AsyncStatus | null>;
+    /**
+     * @description
+     * Intended for TESTING USAGE ONLY. Populates the #assignmentCalls and #allocationPointCalls maps.
+     * This function only works in DEV and LOCAL environments.
+     *
+     * Intended usage:
+     * Used for tests for setting up SDK internal state to test certain scenarios.
+     *
+     * @param {AddExperimentCallsProps} - Required. an object containing optional assignmentCalls and
+     * allocationPointCalls props
+     */
+    addExperimentCalls({ assignmentCalls, allocationPointCalls }: AddExperimentCallsProps<T>): void;
+}
+
+/**
+ * Context values.
+ */
+declare interface ExperimentSDKContextType<T extends TypeData> {
+    /**
+     * An instance of the {@link ExperimentSDK}. "null" by default.
+     */
+    sdkInstance: ExperimentSDK<T> | null;
+}
+
+/**
+ * Context provider properties.
+ * Takes in {@link ExperimentSDKContextType} values, plus the React "children" property
+ */
+declare type ExperimentSDKProviderProps<T extends TypeData> = React.PropsWithChildren<ExperimentSDKContextType<T>>;
+
+declare enum ExperimentTestName {
+    earlyJourneyIndexesGuidance = "EARLY_JOURNEY_INDEXES_GUIDANCE_20250328",
+    mockDataGenerator = "MOCK_DATA_GENERATOR_20251001"
+}
+
+declare enum ExperimentViewedEventName {
+    EXPERIMENT_VIEWED = "Experiment Viewed",
+    EXPERIMENT_GHOSTVIEWED = "Experiment GhostViewed"
+}
+
+declare type FeatureFlags = {
+    enableOidc: boolean;
+    newExplainPlan: boolean;
+    showInsights: boolean;
+    enableExportSchema: boolean;
+    enableRenameCollectionModal: boolean;
+    enableProxySupport: boolean;
+    enableRollingIndexes: boolean;
+    showDisabledConnections: boolean;
+    enableGlobalWrites: boolean;
+    enableDataModeling: boolean;
+    enableIndexesGuidanceExp: boolean;
+    showIndexesGuidanceVariant: boolean;
+    enableContextMenus: boolean;
+    enableSearchActivationProgramP1: boolean;
+    enableUnauthenticatedGenAI: boolean;
+    enableAIAssistant: boolean;
+    enablePerformanceInsightsEntrypoints: boolean;
+};
+
+/**
+ * Represents additional options for ExperimentSDK.getAssignments
+ */
+declare interface GetAssignmentOptions<T extends TypeData> extends BasicAPICallingFunctionOptions<T['loggerTeam']> {
+    /**
+     * Custom properties that will be passed to "trackIsInSample" to be used in the
+     * "Experiment Viewed" call
+     */
+    trackIsInSampleCustomProps?: T['experimentViewedProps'];
+    /**
+     * Set to true to use the entity generic mmsGetAssignmentV3 api method
+     *
+     * @default undefined which will use the deprecated mmsGetAssignment api function instead when unspecified
+     *
+     * @todo remove this property after the deprecated mmsGetAssignment api function is removed.
+     *  Once the deprecated function is removed, by default all getAssignment requests should be using v3.
+     */
+    useV3Assignment?: boolean;
+}
+
+/**
+ * Response object from ExperimentSDK.getProperties
+ * (Very similar to {@link ConstructorOptions} except Logger and TrackerOptions can be null)
+ */
+declare interface GetPropertiesResponse<T extends TypeData> {
+    /** The entityId(s) of the SDK instance. */
+    entityIds: EntityIds;
+    /** Logger-related properties of the SDK instance */
+    loggerOptions: LoggerOptions<T['loggerTeam']> | null;
+    /** Tracker-related properties of the SDK instance */
+    trackerOptions: TrackerOptions<T['experimentViewedProps']> | null;
+    /** The environment of the SDK instance.. */
+    environment: Environment;
+}
+
+/** @public */
+export declare function getRouteFromWorkspaceTab(tab: WorkspaceTab | null): string;
+
+/** @public */
+export declare function getWorkspaceTabFromRoute(route: string): OpenWorkspaceOptions | null;
+
+/**
+ * Valid values to represent the lifecycle of a hook with an async call.
+ * "null" is the default status when a hook is initialized
+ */
+declare enum HookAsyncStatus {
+    LOADING = "LOADING",
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR"
+}
+
+/**
+ * Internally used preferences that are not configurable by users.
+ */
+declare type InternalUserPreferences = {
+    showedNetworkOptIn: boolean;
+    id: string;
+    cloudFeatureRolloutAccess?: {
+        GEN_AI_COMPASS?: boolean;
+    };
+    lastKnownVersion: string;
+    highestInstalledVersion?: string;
+    currentUserId?: string;
+    telemetryAnonymousId?: string;
+    telemetryAtlasUserId?: string;
+    userCreatedAt: number;
+    enableConnectInNewWindow: boolean;
+    showEndOfLifeConnectionModal: boolean;
+};
+
+/**
+ * The interface for a log message + metadata, for use with the {@link Logger}.
+ */
+declare interface Log<LoggerTeam> {
+    logMessage: string;
+    severity: Severity;
+    team?: LoggerTeam;
+}
+
+/** @public */
+export declare type LogFunction = (message: LogMessage) => void;
+
+/**
+ * A Logger object that can be used to monitor SDK health.
+ */
+declare interface Logger<LoggerTeam> {
+    /**
+     * @description
+     * Function to log a message to a log store
+     *
+     * Intended usage:
+     * Call this to log
+     *
+     * @param {string} logMessage - Required
+     * @param {Severity} severity - Required
+     * @param {LoggerTeam} team
+     *
+     * @example
+     * enum LoggerTeam {
+     *  Team1 = 'Test Team 1',
+     * };
+     *
+     * Logger.log({
+     *  logMessage: 'There was an error',
+     *  severity: Severity.ERROR,
+     *  team: LoggerTeam.Team1
+     * });
+     */
+    log: ({ logMessage, severity, team }: Log<LoggerTeam>) => void;
+}
+
+/**
+ * Object representing Logger object and logging-related properties
+ */
+declare interface LoggerOptions<LoggerTeam> {
+    /** A Logger */
+    logger: Logger<LoggerTeam>;
+    /** The default team a log should be assigned to */
+    defaultTeam: LoggerTeam;
+}
+
+/** @public */
+export declare type LogMessage = {
+    id: number;
+    t: {
+        $date: string;
+    };
+    s: 'F' | 'E' | 'W' | 'I' | 'D1' | 'D2' | 'D3' | 'D4' | 'D5';
+    c: string;
+    ctx: string;
+    msg: string;
+    attr?: any;
+};
+
+declare type MyQueriesWorkspace = {
+    type: 'My Queries';
+};
+
+declare type NonUserPreferences = {
+    ignoreAdditionalCommandLineFlags?: boolean;
+    positionalArguments?: string[];
+    file?: string;
+    username?: string;
+    password?: string;
+};
+
+export declare type OpenWorkspaceOptions = Pick<Workspace<'Welcome'>, 'type'> | Pick<Workspace<'My Queries'>, 'type'> | Pick<Workspace<'Data Modeling'>, 'type'> | Pick<Workspace<'Shell'>, 'type' | 'connectionId' | 'initialEvaluate' | 'initialInput'> | Pick<Workspace<'Databases'>, 'type' | 'connectionId'> | Pick<Workspace<'Performance'>, 'type' | 'connectionId'> | Pick<Workspace<'Collections'>, 'type' | 'connectionId' | 'namespace'> | (Pick<Workspace<'Collection'>, 'type' | 'connectionId' | 'namespace'> & Partial<Pick<Workspace<'Collection'>, 'initialQuery' | 'initialAggregation' | 'initialPipeline' | 'initialPipelineText' | 'editViewName'>> & {
+    initialSubtab?: CollectionSubtab;
+});
+
+declare type PermanentFeatureFlags = {
+    showDevFeatureFlags?: boolean;
+    enableDebugUseCsfleSchemaMap?: boolean;
+};
+
+/**
+ * An experiment assignment for a given entity and experiment in the SDK.
+ * This represents an assignment object in {@link ExperimentSDK.#assignmentsMap}
+ */
+declare interface SDKAssignment<ExperimentName, ExperimentVariantName> {
+    /**
+     * Critical data about the specific entity's assignment
+     */
+    assignmentData: AssignmentData<ExperimentVariantName>;
+    /**
+     * All the information from the server about the experiment and the entity's assignment
+     */
+    experimentData: ServerAssignment<ExperimentName, ExperimentVariantName>;
+}
+
+/**
+ * An experiment attribute in the SDK.
+ * This represents an experiment attribute object in {@link ExperimentSDK.#experimentAttributesMap}
+ */
+declare type SDKExperimentAttributes<ExperimentAttributeName extends string> = {
+    [key in ExperimentAttributeName]?: ExperimentAttributeValue;
+};
+
+/**
+ * A GHOST experiment assignment for a given entity and experiment in the SDK.
+ * This represents an assignment object in {@link ExperimentSDK.#ghostAssignmentsMap}
+ */
+declare interface SDKGhostAssignment<ExperimentName, ExperimentVariantName> {
+    /**
+     * Critical data about the specific entity's assignment
+     */
+    assignmentData: AssignmentData<ExperimentVariantName>;
+    /**
+     * All the information from the server about the experiment and the entity's GHOST assignment
+     */
+    experimentData: ServerGhostAssignment<ExperimentName, ExperimentVariantName>;
+}
+
+/**
+ * An experiment assignment for a given entity and experiment.
+ * This represents the raw assignment data fed into {@link ExperimentSDK.addExistingExperimentData}.
+ * (FYI The below interface is taken from MMS: packages/types/abTest.ts)
+ */
+declare interface ServerAssignment<ExperimentName, ExperimentVariantName> {
+    /**
+     * The date of the experiment assignment, in ms.
+     * @example
+     * "1658340252128"
+     */
+    assignmentDate: string;
+    /**
+     * The ID of the entity assigned.
+     * @example
+     * "621509aae911cb2e37ba91ca"
+     */
+    entityId: string;
+    /**
+     * The "type" of entity. Experiments are configured to allocate specific entity types.
+     * @example
+     * "ORG"
+     */
+    entityType: EntityType;
+    /**
+     * ID of the experiment assignment. Normally populated, but can be null
+     * if the Assignment is for a LAUNCHED experiment.
+     * @example
+     * "62d8439c9ce6473793cff6ca"
+     */
+    id: string | null;
+    /**
+     * Experiment tag, set in the experiment configuration. Experiments on the same tag
+     * are mutually exclusive.
+     * @example
+     * "activation"
+     */
+    tag: string;
+    /**
+     * The ID of the experiment configuration.
+     * @example
+     * "62bb810b61be7d017fcc2198"
+     */
+    testId: string;
+    /**
+     * The name of the experiment. Should be a value from the {@link TypeData.experimentName} enum.
+     * @example
+     * "ATLAS_SEARCH_IN_PROJECT_SIDE_NAV_20220620"
+     */
+    testName: ExperimentName;
+    /**
+     * The name of the assigned experiment variant for the entity.
+     * (Confusingly is NOT an ObjectId.)
+     * If defined, should be a value from the {@link TypeData.experimentVariantName} enum.
+     * The "/assign" server response will have this always
+     * defined as a string, but the "/params" and "/assignByPoint" endpoints may have "null" for an
+     * experiment, which would mean the entity is NOT allocated into the experiment
+     * (aka not in any of the variants, including control).
+     *
+     * @example
+     * "atlasSearchProjectSideNavControl"
+     */
+    testGroupId: ExperimentVariantName | null;
+    /**
+     * The ID of the assigned experiment variant for the entity.
+     * The "/assign" server response will have this always
+     * defined as a string, but the "/params" and "/assignByPoint" endpoints may have "null" for an
+     * experiment, which would mean the entity is NOT allocated into the experiment
+     * (aka not in any of the variants, including control).
+     *
+     * @example
+     * "62bb810b61be7d017fcc2196"
+     */
+    testGroupDatabaseId: string | null;
+    /**
+     * An object containing assignment metadata, which currently consists of 1 field (isLaunchedExperiment).
+     * Should normally be present, though can be "null" for 1. older assignments, or 2. override assignments.
+     *
+     * @example
+     * { isLaunchedExperiment: false }
+     */
+    meta: {
+        isLaunchedExperiment: boolean;
+    } | null;
+}
+
+/**
+ * Server-formatted assignment array that's specific to the passed in list of possible experiment and variant names.
+ */
+declare type ServerAssignments<T extends TypeData> = Array<ServerAssignment<T['experimentName'], T['experimentVariantName']>>;
+
+/** Server-formatted map of experiment attribute keys to values. */
+declare type ServerExperimentAttributeMap<T extends TypeData> = ServerExperimentAttributes<T['experimentAttributeName']>;
+
+/**
+ * An experiment attribute from the server. The values are all strings.
+ * This represents the raw experiment attribute data fed into {@link ExperimentSDK.addExistingExperimentData}
+ * (which takes cares of transforming the strings into booleans and numbers as needed).
+ * (FYI The below interface is taken from MMS: js/admin/controlpanel/types/abTest.ts)
+ */
+declare type ServerExperimentAttributes<ExperimentAttributeName extends string> = {
+    [key in ExperimentAttributeName]?: string;
+};
+
+/**
+ * A GHOST experiment assignment for a given entity and experiment. Extends the base "ServerAssignment" type.
+ * This represents the raw assignment data fed into {@link ExperimentSDK.addExistingExperimentData}.
+ * (FYI The below interface is taken from MMS: packages/types/abTest.ts)
+ */
+declare interface ServerGhostAssignment<ExperimentName, ExperimentVariantName> extends ServerAssignment<ExperimentName, ExperimentVariantName> {
+    /**
+     * The ID of the Holdout experiment which is responsible for the entity getting a
+     * ghost assignment for the given test (aka the experiment represented by testName/testId).
+     * Ghost assignments should always have this field populated.
+     * (Ghost assignments are used for trackIsInSample functionality and can be ignored by most consumers.)
+     *
+     * @example
+     * "645e70f9e40f6ce91c1efbaf"
+     */
+    linkedHoldoutTestId: string;
+    /**
+     * The name of the Holdout experiment which is responsible for the entity getting a
+     * ghost assignment for the given test (aka the experiment represented by testName/testId).
+     * Ghost assignments should always have this field populated.
+     * NOT necessarily a {@link TypeData.experimentName} enum value, as Holdout experiments are
+     * generally configured and managed outside of the client platform.
+     * (Ghost assignments are used for trackIsInSample functionality and can be ignored by most consumers.)
+     *
+     * @example
+     * "HOLDOUT_2Q2023"
+     */
+    linkedHoldoutTestName: string;
+}
+
+declare type ServerStatsWorkspace = {
+    type: 'Performance';
+    connectionId: string;
+};
+
+/**
+ * The different values of severity for logging
+ */
+declare enum Severity {
+    INFO = "info",
+    WARNING = "warning",
+    ERROR = "error"
+}
+
+declare type ShellWorkspace = {
+    type: 'Shell';
+    connectionId: string;
+    initialEvaluate?: string | string[];
+    initialInput?: string;
+};
+
+declare const SORT_ORDER_VALUES: readonly ["", "{ _id: 1 }", "{ _id: -1 }", "{ $natural: -1 }"];
+
+declare type SORT_ORDERS = (typeof SORT_ORDER_VALUES)[number];
+
+/**
+ * Commonly used status codes (for {@link AsyncStatus})
+ * Currently we only create AsyncStatus objects for success states; errors are thrown
+ * and bubble up instead, hence why only 20X status codes are represented here.
+ */
+declare enum StatusCode {
+    SUCCESS = 200,
+    ACCEPTED = 202
+}
+
+declare type THEMES = (typeof THEMES_VALUES)[number];
+
+declare const THEMES_VALUES: readonly ["DARK", "LIGHT", "OS_THEME"];
+
+/**
+ * A Tracker object that can send data on client metrics.
+ */
+declare interface Tracker<ExperimentViewedProps> {
+    /**
+     * @description
+     * Function that broadcasts client-side analytics events
+     *
+     * Intended usage:
+     * Used by the function `trackIsInSample` to broadcast 'Experiment Viewed' and 'Experiment GhostViewed' events
+     *
+     * @param {
+         *   {
+         *     eventName: 'Experiment Viewed',
+         *     properties?: {},
+         *     timeout?: number,
+         *   }
+         * } trackOptions - Required
+         *
+         * @return {Promise<void | Error | { message?: string }>}
+         * Calling `track` will always return a promise.
+         * - If the call is successful, the value of the promise will be void.
+         * - If there is an error, the value of the promise will be the error.
+         * - In some specific situations, the value of the promise will be an object with a key `message`.
+         * -- {@link https://github.com/10gen/heliotrope|Heliotrope} returns these "objects with a message"
+         * -- when it caches an analytics call (tries to make a track call before Heliotrope is
+         * -- initialized), or when it attempts to make a track call when Heliotrope is not enabled.
+         *
+         * @example
+         * `const trackPromise = this.#tracker.track({
+         *   eventName: 'Experiment Viewed',
+         *   properties: {
+         *     customProperty: 'A Relevant Value',
+         *   },
+         *   timeout: 100,
+         * });`
+         *
+         * Note: `this.#tracker.track()` will only be called via `ExperimentSDK.trackIsInSample({...})`, and not
+         * by the SDK's consumers.
+         *
+         * Note: Any properties that are passed into the `properties` object will have to match the
+         * `experimentViewedProps` type that was passed in when the SDK was initialized.
+         *
+         */
+     track: (trackOptions: {
+         eventName: ExperimentViewedEventName;
+         properties?: ExperimentViewedProps;
+         timeout?: number;
+     }) => Promise<void | Error | {
+         message?: string;
+     }>;
+    }
+
+    /**
+     * Object representing Tracker object and tracking-related properties
+     */
+    declare interface TrackerOptions<ExperimentViewedProps> {
+        /** A Tracker */
+        tracker: Tracker<ExperimentViewedProps>;
+    }
+
+    /** @public */
+    export declare type TrackFunction = (event: string, properties: Record<string, any>) => void;
+
+    /**
+     * An optional type interface consumers can pass in during initializiation
+     * to enforce enums for Experiment data. It is highly encouraged to pass this typing
+     * in.
+     */
+    declare type TypeData = {
+        /**
+         * Enum representing experiment names. Should match expected values for
+         * {@link ExperimentAssignment.testName}
+         * @example
+         * enum ExperimentName {
+         *  EXP_ONE = 'expOne',
+         * };
+         * const types: TypeData = {
+         *  experimentName: ExperimentName,
+         *  ...
+         * }
+         */
+        experimentName: string;
+        /**
+         * Enum representing experiment variant names. Should match expected values for
+         * {@link ExperimentAssignment.testGroupId}
+         * @example
+         * enum ExperimentVariantName {
+         *  EXP_VARIANT_ONE = 'expVariantOne',
+         * };
+         * const types: TypeData = {
+         *  experimentVariantName: ExperimentVariantName,
+         *  ...
+         * }
+         */
+        experimentVariantName: string;
+        /**
+         * Enum representing experiment attribute names
+         * @example
+         * enum ExperimentAttributeName {
+         *  SHOW_LEFT_NAV_LINK = 'showLeftNavLink',
+         * };
+         * const types: TypeData = {
+         *  experimentAttributeName: ExperimentAttributeName,
+         *  ...
+         * }
+         */
+        experimentAttributeName: string;
+        /**
+         * Enum representing allocation point names
+         * @example
+         * enum AllocationPointName {
+         *  CLUSTER_CARD_PAGE = 'CLUSTER_CARD_PAGE',
+         * };
+         * const types: TypeData = {
+         *  allocationPointName: AllocationPointName,
+         *  ...
+         * }
+         */
+        allocationPointName: string;
+        /**
+         * Type/Interface containing key/value pairs of properties that may be included in the
+         * "Experiment Ghost/Viewed" event
+         *
+         * @example
+         * export interface ExperimentViewedBaseEvent {
+         *   test_name: TestName;
+         *   test_group_name: TestGroupName;
+         * }
+         * interface ExperimentViewedPropertiesForExperimentA {
+         *   aCustomProp: string;
+         * }
+         * interface ExperimentViewedPropertiesForExperimentB {
+         *   aSecondCustomProp: string;
+         *   aThirdCustomProp: string;
+         * }
+         * type ExperimentViewedAdditionalProperties =
+         *   | ExperimentViewedPropertiesForExperimentA | ExperimentViewedPropertiesForExperimentB;
+         * type ExperimentViewedEventProps =
+         *   | ExperimentViewedBaseEvent
+         *   | (ExperimentViewedBaseEvent & ExperimentViewedAdditionalProperties);
+         *
+         * const types: TypesToPassIn = {
+         *   experimentViewedProps: ExperimentViewedEventProps,
+         *   ...
+         * }
+         */
+        experimentViewedProps: {
+            [name: string]: string | number;
+        };
+        /**
+         * Enum representing different teams that can be assigned application logs
+         * @example
+         * enum LoggerTeam {
+         *  Team1 = 'Test Team 1',
+         * };
+         * const types: TypeData = {
+         *  loggerTeam: LoggerTeam,
+         *  ...
+         * }
+         */
+        loggerTeam: string;
+    };
+
+    export declare namespace types {
+        export {
+            Environment,
+            StatusCode,
+            Severity,
+            EntityType,
+            TypeData,
+            AsyncStatus,
+            ServerAssignment,
+            ServerGhostAssignment,
+            AssignmentData,
+            SDKAssignment,
+            SDKGhostAssignment,
+            ServerExperimentAttributes,
+            ExperimentAttributeValue,
+            SDKExperimentAttributes,
+            EntityIds,
+            Log,
+            Logger,
+            LoggerOptions,
+            Tracker,
+            TrackerOptions,
+            ConstructorOptions,
+            GetPropertiesResponse,
+            ExistingData,
+            AddExperimentCallsProps,
+            AddExistingExperimentDataOptions,
+            GetAssignmentOptions,
+            AssignOptions,
+            AssignByPointsOptions,
+            AssignmentsMap
+        }
+    }
+
+    export declare namespace typesReact {
+        export {
+            HookAsyncStatus,
+            ExperimentSDKContextType,
+            ExperimentSDKProviderProps,
+            UseTrackIsInSampleConfig,
+            UseAssignmentOptions,
+            BasicHookResponse,
+            UseAssignmentResponse
+        }
+    }
+
+    declare type UseAssignmentHook = (experimentName: ExperimentTestName, trackIsInSample: boolean, options?: typesReact.UseAssignmentOptions<types.TypeData>) => typesReact.UseAssignmentResponse<types.TypeData>;
+
+    /**
+     * Additional options the useAssignment hook can take beyond the {@link GetAssignmentOptions} options.
+     */
+    declare interface UseAssignmentOptions<T extends TypeData> extends GetAssignmentOptions<T> {
+        /**
+         * An optional array of {@link BasicHookResponse} objects that should trigger a refetch of assignments.
+         * For example, if you want to refetch assignments after a "useAssign" call is complete, you can pass
+         * the return value of "useAssign" in this array.
+         */
+        hookDependencies?: Array<BasicHookResponse>;
+    }
+
+    /**
+     * Additional response props of the {@link useAssignment} hook.
+     */
+    declare interface UseAssignmentResponse<T extends TypeData> extends BasicHookResponse {
+        assignment: SDKAssignment<T['experimentName'], T['experimentVariantName']> | null;
+    }
+
+    declare type UserConfigurablePreferences = PermanentFeatureFlags & FeatureFlags & {
+        autoUpdates: boolean;
+        enableGenAIFeatures: boolean;
+        enableMaps: boolean;
+        trackUsageStatistics: boolean;
+        enableFeedbackPanel: boolean;
+        networkTraffic: boolean;
+        readOnly: boolean;
+        enableShell: boolean;
+        enableDbAndCollStats: boolean;
+        protectConnectionStrings?: boolean;
+        forceConnectionOptions?: [key: string, value: string][];
+        showKerberosPasswordField: boolean;
+        showOIDCDeviceAuthFlow: boolean;
+        browserCommandForOIDCAuth?: string;
+        persistOIDCTokens?: boolean;
+        enableDevTools: boolean;
+        theme: THEMES;
+        maxTimeMS?: number;
+        installURLHandlers: boolean;
+        protectConnectionStringsForNewConnections: boolean;
+        atlasServiceBackendPreset: 'atlas-local' | 'atlas-dev' | 'atlas-qa' | 'atlas' | 'web-sandbox-atlas-local' | 'web-sandbox-atlas-dev' | 'web-sandbox-atlas-qa' | 'web-sandbox-atlas';
+        optInGenAIFeatures: boolean;
+        enableExplainPlan: boolean;
+        enableAtlasSearchIndexes: boolean;
+        enableImportExport: boolean;
+        enableAggregationBuilderRunPipeline: boolean;
+        enableAggregationBuilderExtraOptions: boolean;
+        enableGenAISampleDocumentPassing: boolean;
+        enablePerformanceAdvisorBanner: boolean;
+        maximumNumberOfActiveConnections?: number;
+        defaultSortOrder: SORT_ORDERS;
+        enableShowDialogOnQuit: boolean;
+        enableCreatingNewConnections: boolean;
+        enableProxySupport: boolean;
+        proxy: string;
+        inferNamespacesFromPrivileges?: boolean;
+    };
+
+    declare type UserPreferences = UserConfigurablePreferences & InternalUserPreferences & AtlasOrgPreferences & AtlasProjectPreferences;
+
+    /**
+     * Config object passed into the {@link useTrackIsInSample} hook.
+     */
+    declare interface UseTrackIsInSampleConfig<ExperimentViewedProps, LoggerTeam> {
+        experimentName: string;
+        shouldFireEvent?: boolean;
+        customProperties?: ExperimentViewedProps;
+        team?: LoggerTeam;
+    }
+
+    declare type WelcomeWorkspace = {
+        type: 'Welcome';
+    };
+
+    declare type Workspace<T extends AnyWorkspace['type']> = Extract<AnyWorkspace, {
+        type: T;
+    }>;
+
+    export declare type WorkspaceTab = {
+        id: string;
+    } & WorkspaceTabProps;
+
+    declare type WorkspaceTabProps = WelcomeWorkspace | MyQueriesWorkspace | DataModelingWorkspace | ShellWorkspace | ServerStatsWorkspace | DatabasesWorkspace | CollectionsWorkspace | (Omit<CollectionWorkspace, 'tabId'> & {
+        subTab: CollectionSubtab;
+    });
+
+    export { }