@donotuse/eas-cli 18.5.0-rc.1

package/build/rollout/actions/NonInteractiveRollout.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonInteractiveRollout = void 0;
+const tslib_1 = require("tslib");
+const CreateRollout_1 = require("./CreateRollout");
+const EditRollout_1 = require("./EditRollout");
+const EndRollout_1 = require("./EndRollout");
+const ManageRollout_1 = require("./ManageRollout");
+const RolloutMainMenu_1 = require("./RolloutMainMenu");
+const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const json_1 = require("../../utils/json");
+const branch_mapping_1 = require("../branch-mapping");
+const utils_1 = require("../utils");
+/**
+ * Control a rollout in non interactive mode.
+ */
+class NonInteractiveRollout {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        const { channelName, action } = this.options;
+        const { nonInteractive, app, graphqlClient } = ctx;
+        if (!nonInteractive) {
+            throw new Error(`This action is meant for non-interactive mode.`);
+        }
+        if (!channelName) {
+            throw new Error(`The channel argument is required in non-interactive mode. Run eas channel:rollout [channel-name]`);
+        }
+        const channelInfo = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: app.projectId,
+            channelName,
+        });
+        const channelObject = await this.getChannelObjectAsync(ctx, {
+            channelName,
+            runtimeVersion: this.getRuntimeVersion(channelInfo),
+        });
+        if (!action) {
+            throw new Error(`--action is required in non-interactive mode.`);
+        }
+        const updatedChannelInfo = await this.runActionAsync(ctx, action, channelObject);
+        const updatedChannelObject = await this.getChannelObjectAsync(ctx, {
+            channelName,
+            runtimeVersion: this.getRuntimeVersion(updatedChannelInfo),
+        });
+        if (this.options.json) {
+            const json = await this.getJsonAsync({
+                originalChannelObject: channelObject,
+                updatedChannelObject,
+            });
+            (0, json_1.printJsonOnlyOutput)(json);
+        }
+    }
+    async runActionAsync(ctx, action, channelObject) {
+        switch (action) {
+            case RolloutMainMenu_1.MainMenuActions.CREATE_NEW:
+                return await new CreateRollout_1.CreateRollout(channelObject, this.options).runAsync(ctx);
+            case ManageRollout_1.ManageRolloutActions.EDIT:
+                return await new EditRollout_1.EditRollout(channelObject, this.options).runAsync(ctx);
+            case ManageRollout_1.ManageRolloutActions.END:
+                return await new EndRollout_1.EndRollout(channelObject, this.options).runAsync(ctx);
+            case ManageRollout_1.ManageRolloutActions.VIEW:
+                return this.viewRollout(channelObject);
+        }
+    }
+    viewRollout(channelObject) {
+        if (!this.options.json) {
+            (0, utils_1.printRollout)(channelObject);
+            log_1.default.warn('For formatted output, add the --json flag to your command.');
+        }
+        return channelObject;
+    }
+    async getJsonAsync({ originalChannelObject, updatedChannelObject, }) {
+        return {
+            hasRollout: (0, branch_mapping_1.isRollout)(updatedChannelObject),
+            ...((0, branch_mapping_1.isRollout)(originalChannelObject)
+                ? { originalRolloutInfo: await this.getRolloutJsonAsync(originalChannelObject) }
+                : {}),
+            ...((0, branch_mapping_1.isRollout)(updatedChannelObject)
+                ? { currentRolloutInfo: await this.getRolloutJsonAsync(updatedChannelObject) }
+                : {}),
+        };
+    }
+    async getRolloutJsonAsync(channelObject) {
+        const rollout = (0, branch_mapping_1.getRollout)(channelObject);
+        return {
+            defaultBranch: rollout.defaultBranch,
+            rolledOutBranch: rollout.rolledOutBranch,
+            percentRolledOut: rollout.percentRolledOut,
+            runtimeVersion: this.getRuntimeVersion(channelObject) ?? undefined,
+            updatedAt: channelObject.updatedAt,
+        };
+    }
+    getRuntimeVersion(channelInfo) {
+        if ((0, branch_mapping_1.isRollout)(channelInfo)) {
+            const updatedRolloutInfo = (0, branch_mapping_1.getRolloutInfo)(channelInfo);
+            if ((0, branch_mapping_1.isConstrainedRolloutInfo)(updatedRolloutInfo)) {
+                return updatedRolloutInfo.runtimeVersion;
+            }
+        }
+        return undefined;
+    }
+    async getChannelObjectAsync(ctx, { channelName, runtimeVersion }) {
+        const { graphqlClient, app } = ctx;
+        const { projectId } = app;
+        return await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: projectId,
+            channelName,
+            ...(runtimeVersion ? { filter: { runtimeVersions: [runtimeVersion] } } : {}),
+        });
+    }
+}
+exports.NonInteractiveRollout = NonInteractiveRollout;

package/build/rollout/actions/RolloutMainMenu.d.ts

@@ -0,0 +1,27 @@
+import { NonInteractiveOptions as CreateRolloutNonInteractiveOptions } from './CreateRollout';
+import { NonInteractiveOptions as EditRolloutNonInteractiveOptions } from './EditRollout';
+import { GeneralOptions as EndRolloutGeneralOptions, NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
+import { ManageRolloutActions } from './ManageRollout';
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+export declare enum MainMenuActions {
+    CREATE_NEW = "Create a new rollout",
+    MANAGE_EXISTING = "Manage an existing rollout"
+}
+export type RolloutActions = MainMenuActions.CREATE_NEW | ManageRolloutActions.EDIT | ManageRolloutActions.END | ManageRolloutActions.VIEW;
+/**
+ * Manage a rollout for the project.
+ */
+export declare class RolloutMainMenu implements EASUpdateAction<void> {
+    private readonly options;
+    constructor(options: {
+        channelName?: string;
+        action?: RolloutActions;
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & EndRolloutGeneralOptions & Partial<CreateRolloutNonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<void>;
+    private runActionAsync;
+    private selectRolloutAsync;
+    private selectChannelToRolloutAsync;
+    private resolveChannelNameAsync;
+    private toMainMenuAction;
+    private promptMenuActionAsync;
+}

package/build/rollout/actions/RolloutMainMenu.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RolloutMainMenu = exports.MainMenuActions = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const CreateRollout_1 = require("./CreateRollout");
+const ManageRollout_1 = require("./ManageRollout");
+const SelectRollout_1 = require("./SelectRollout");
+const SelectChannel_1 = require("../../channel/actions/SelectChannel");
+const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const branch_mapping_1 = require("../branch-mapping");
+var MainMenuActions;
+(function (MainMenuActions) {
+    MainMenuActions["CREATE_NEW"] = "Create a new rollout";
+    MainMenuActions["MANAGE_EXISTING"] = "Manage an existing rollout";
+})(MainMenuActions || (exports.MainMenuActions = MainMenuActions = {}));
+/**
+ * Manage a rollout for the project.
+ */
+class RolloutMainMenu {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        const { action } = this.options;
+        const { nonInteractive } = ctx;
+        if (nonInteractive) {
+            throw new Error(`rollout main menu cannot be run in non-interactive mode.`);
+        }
+        const menuOption = action ? this.toMainMenuAction(action) : await this.promptMenuActionAsync();
+        await this.runActionAsync(ctx, menuOption);
+    }
+    async runActionAsync(ctx, menuAction) {
+        const { channelName } = this.options;
+        switch (menuAction) {
+            case MainMenuActions.CREATE_NEW: {
+                const channelInfo = channelName
+                    ? await this.resolveChannelNameAsync(ctx, channelName)
+                    : await this.selectChannelToRolloutAsync(ctx);
+                await new CreateRollout_1.CreateRollout(channelInfo, this.options).runAsync(ctx);
+                return null;
+            }
+            case MainMenuActions.MANAGE_EXISTING: {
+                const channelInfo = channelName
+                    ? await this.resolveChannelNameAsync(ctx, channelName)
+                    : await this.selectRolloutAsync(ctx);
+                if (!channelInfo) {
+                    log_1.default.log('You dont have any rollouts.');
+                }
+                else {
+                    (0, assert_1.default)(this.options.action !== MainMenuActions.CREATE_NEW, 'Invalid route for create action');
+                    const manageAction = await new ManageRollout_1.ManageRollout(channelInfo, {
+                        ...this.options,
+                        action: this.options.action,
+                        callingAction: this,
+                    }).runAsync(ctx);
+                    await manageAction.runAsync(ctx);
+                }
+                return null;
+            }
+        }
+    }
+    async selectRolloutAsync(ctx) {
+        const selectRollout = new SelectRollout_1.SelectRollout();
+        const channelInfo = await selectRollout.runAsync(ctx);
+        return channelInfo;
+    }
+    async selectChannelToRolloutAsync(ctx) {
+        let hasSomeChannel = false;
+        const selectChannelAction = new SelectChannel_1.SelectChannel({
+            filterPredicate: (channelInfo) => {
+                hasSomeChannel = true;
+                return !(0, branch_mapping_1.isRollout)(channelInfo);
+            },
+        });
+        const channelInfo = await selectChannelAction.runAsync(ctx);
+        if (!channelInfo) {
+            const error = hasSomeChannel
+                ? new Error('All your channels are already part of a rollout.')
+                : new Error(`You dont have any channels. Create one with \`eas channel:create\``);
+            throw error;
+        }
+        return channelInfo;
+    }
+    async resolveChannelNameAsync(ctx, channelName) {
+        const { graphqlClient, app } = ctx;
+        return await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: app.projectId,
+            channelName,
+        });
+    }
+    toMainMenuAction(action) {
+        if (action === MainMenuActions.CREATE_NEW) {
+            return MainMenuActions.CREATE_NEW;
+        }
+        else if (action === ManageRollout_1.ManageRolloutActions.EDIT ||
+            action === ManageRollout_1.ManageRolloutActions.END ||
+            action === ManageRollout_1.ManageRolloutActions.VIEW) {
+            return MainMenuActions.MANAGE_EXISTING;
+        }
+        else {
+            throw new Error(`Action not supported yet: ` + action);
+        }
+    }
+    async promptMenuActionAsync() {
+        const menuOptions = [MainMenuActions.CREATE_NEW, MainMenuActions.MANAGE_EXISTING];
+        const { menuOption: selectedMenuOption } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'menuOption',
+            message: `What would you like to do?`,
+            choices: menuOptions.map(menuOption => ({
+                value: menuOption,
+                title: menuOption,
+            })),
+        });
+        return selectedMenuOption;
+    }
+}
+exports.RolloutMainMenu = RolloutMainMenu;

package/build/rollout/actions/SelectRollout.d.ts

@@ -0,0 +1,8 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+/**
+ * Select an existing rollout for the project.
+ */
+export declare class SelectRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment | null> {
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment | null>;
+}

package/build/rollout/actions/SelectRollout.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectRollout = void 0;
+const SelectChannel_1 = require("../../channel/actions/SelectChannel");
+const ora_1 = require("../../ora");
+const branch_mapping_1 = require("../branch-mapping");
+/**
+ * Select an existing rollout for the project.
+ */
+class SelectRollout {
+    async runAsync(ctx) {
+        let assetSpinner = null;
+        const afterEachFilterQuery = (_externalQueryParams, totalNodesFetched, _dataset, willFetchAgain) => {
+            if (willFetchAgain && !assetSpinner) {
+                assetSpinner = (0, ora_1.ora)().start('Fetching channels...');
+            }
+            if (assetSpinner) {
+                assetSpinner.text = `Fetched ${totalNodesFetched} channels`;
+            }
+        };
+        const selectChannelAction = new SelectChannel_1.SelectChannel({
+            printedType: 'rollout',
+            filterPredicate: branch_mapping_1.isRollout,
+            afterEachFilterQuery,
+        });
+        const channelInfo = await selectChannelAction.runAsync(ctx);
+        if (assetSpinner) {
+            assetSpinner.succeed(`Fetched all channels`);
+        }
+        return channelInfo;
+    }
+}
+exports.SelectRollout = SelectRollout;

package/build/rollout/actions/SelectRuntime.d.ts

@@ -0,0 +1,19 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateBranchBasicInfoFragment } from '../../graphql/generated';
+/**
+ * Select a runtime from a branch
+ */
+export declare class SelectRuntime implements EASUpdateAction<string | null> {
+    private readonly branchInfo;
+    private readonly options;
+    private readonly printedType;
+    constructor(branchInfo: UpdateBranchBasicInfoFragment, options?: {
+        anotherBranchToIntersectRuntimesBy?: UpdateBranchBasicInfoFragment;
+    });
+    private warnNoRuntime;
+    private formatCantFindRuntime;
+    runAsync(ctx: EASUpdateContext): Promise<string | null>;
+    private getNewestRuntimeAsync;
+    private displayLatestUpdateGroupAsync;
+    private selectRuntimesAsync;
+}

package/build/rollout/actions/SelectRuntime.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectRuntime = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const utils_1 = require("../../eas-update/utils");
+const RuntimeQuery_1 = require("../../graphql/queries/RuntimeQuery");
+const UpdateQuery_1 = require("../../graphql/queries/UpdateQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const prompts_1 = require("../../prompts");
+const relay_1 = require("../../utils/relay");
+const utils_2 = require("../utils");
+/**
+ * Select a runtime from a branch
+ */
+class SelectRuntime {
+    branchInfo;
+    options;
+    printedType;
+    constructor(branchInfo, options = {}) {
+        this.branchInfo = branchInfo;
+        this.options = options;
+        this.printedType = options.anotherBranchToIntersectRuntimesBy
+            ? `compatible runtime`
+            : `runtime`;
+    }
+    warnNoRuntime() {
+        if (this.options.anotherBranchToIntersectRuntimesBy) {
+            const intersectBranchName = this.options.anotherBranchToIntersectRuntimesBy.name;
+            log_1.default.warn(`⚠️  Branches ${this.branchInfo.name} and ${intersectBranchName} dont have any updates with the same runtime.`);
+            log_1.default.warn(`Your updates could be misconfigured. ${(0, log_1.learnMore)('https://expo.fyi/eas-update-rollouts')}`);
+        }
+        else {
+            // no runtime on branch means no updates published on branch
+            log_1.default.warn(`⚠️  There are no updates published on branch ${this.branchInfo.name}.`);
+        }
+    }
+    formatCantFindRuntime() {
+        return `🕵️ Not finding the update you were looking for? ${(0, log_1.learnMore)('https://expo.fyi/eas-update-rollouts')}`;
+    }
+    async runAsync(ctx) {
+        const { nonInteractive, graphqlClient, app } = ctx;
+        const { projectId } = app;
+        if (nonInteractive) {
+            const runtimes = await this.getNewestRuntimeAsync(graphqlClient, {
+                appId: projectId,
+                branchName: this.branchInfo.name,
+                anotherBranchIdToIntersectRuntimesBy: this.options.anotherBranchToIntersectRuntimesBy?.id,
+            });
+            if (runtimes.edges.length === 0) {
+                throw new utils_1.NonInteractiveError(`No ${this.printedType} versions found on branch "${this.branchInfo.name}".`);
+            }
+            const runtimeList = runtimes.edges.map(e => e.node.version).join('\n  ');
+            throw new utils_1.NonInteractiveError(`Runtime selection cannot be run in non-interactive mode. Available ${this.printedType} versions on branch "${this.branchInfo.name}":\n  ${runtimeList}`);
+        }
+        const newestRuntimeConnection = await this.getNewestRuntimeAsync(graphqlClient, {
+            appId: projectId,
+            branchName: this.branchInfo.name,
+            anotherBranchIdToIntersectRuntimesBy: this.options.anotherBranchToIntersectRuntimesBy?.id,
+        });
+        if (newestRuntimeConnection.edges.length === 0) {
+            log_1.default.addNewLineIfNone();
+            this.warnNoRuntime();
+            return null;
+        }
+        const onlyOneRuntime = newestRuntimeConnection.edges.length === 1 && !newestRuntimeConnection.pageInfo.hasNextPage;
+        log_1.default.log(`✅ ${beginSentence(this.printedType)}${onlyOneRuntime ? '' : 's'} detected`);
+        if (onlyOneRuntime) {
+            const runtime = newestRuntimeConnection.edges[0].node;
+            const formattedRuntimeWithGroup = await this.displayLatestUpdateGroupAsync({
+                graphqlClient,
+                appId: projectId,
+                branchName: this.branchInfo.name,
+                runtime,
+            });
+            log_1.default.addNewLineIfNone();
+            log_1.default.log(formattedRuntimeWithGroup);
+            log_1.default.addNewLineIfNone();
+            const useRuntime = await (0, prompts_1.confirmAsync)({
+                message: `Target ${this.printedType} ${chalk_1.default.bold(runtime.version)}?`,
+            });
+            if (useRuntime) {
+                return runtime.version;
+            }
+            else {
+                log_1.default.newLine();
+                log_1.default.warn(this.formatCantFindRuntime());
+                return null;
+            }
+        }
+        log_1.default.log(this.formatCantFindRuntime());
+        const selectedRuntime = await this.selectRuntimesAsync(graphqlClient, {
+            appId: projectId,
+        });
+        if (!selectedRuntime) {
+            throw new Error(`No ${this.printedType} selected`);
+        }
+        return selectedRuntime.version;
+    }
+    async getNewestRuntimeAsync(graphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, }) {
+        return await RuntimeQuery_1.RuntimeQuery.getRuntimesOnBranchAsync(graphqlClient, {
+            appId,
+            name: branchName,
+            first: 1,
+            filter: {
+                branchId: anotherBranchIdToIntersectRuntimesBy,
+            },
+        });
+    }
+    async displayLatestUpdateGroupAsync({ graphqlClient, appId, branchName, runtime, }) {
+        const updateGroups = await UpdateQuery_1.UpdateQuery.viewUpdateGroupsOnBranchAsync(graphqlClient, {
+            appId,
+            branchName,
+            limit: 1,
+            offset: 0,
+            filter: {
+                runtimeVersions: [runtime.version],
+            },
+        });
+        (0, assert_1.default)(updateGroups.length < 2, `Expected at most one update group. Received: ${JSON.stringify(updateGroups)}`);
+        return (0, utils_2.formatRuntimeWithUpdateGroup)(updateGroups[0], runtime, branchName);
+    }
+    async selectRuntimesAsync(graphqlClient, { appId, batchSize = 5, }) {
+        const queryAsync = async (queryParams) => {
+            return await RuntimeQuery_1.RuntimeQuery.getRuntimesOnBranchAsync(graphqlClient, {
+                appId,
+                name: this.branchInfo.name,
+                first: queryParams.first,
+                after: queryParams.after,
+                last: queryParams.last,
+                before: queryParams.before,
+                filter: {
+                    branchId: this.options.anotherBranchToIntersectRuntimesBy?.id,
+                },
+            });
+        };
+        const getTitleAsync = async (runtime) => {
+            return await this.displayLatestUpdateGroupAsync({
+                graphqlClient,
+                appId,
+                branchName: this.branchInfo.name,
+                runtime,
+            });
+        };
+        return await (0, relay_1.selectPaginatedAsync)({
+            queryAsync,
+            getTitleAsync,
+            printedType: 'target runtime',
+            pageSize: batchSize,
+        });
+    }
+}
+exports.SelectRuntime = SelectRuntime;
+function beginSentence(phrase) {
+    if (typeof phrase !== 'string' || phrase.length === 0) {
+        return phrase; // Return the input without any modification if it's not a string or empty
+    }
+    return phrase.charAt(0).toUpperCase() + phrase.slice(1);
+}

package/build/rollout/branch-mapping.d.ts

@@ -0,0 +1,128 @@
+import { BranchMapping, BranchMappingAlwaysTrue } from '../channel/branch-mapping';
+import { BranchBasicInfo, ChannelBasicInfo, UpdateChannelInfoWithBranches } from '../channel/utils';
+export type Rollout<Branch extends BranchBasicInfo> = LegacyRollout<Branch> | ConstrainedRollout<Branch>;
+export type RolloutInfo = LegacyRolloutInfo | ConstrainedRolloutInfo;
+type ConstrainedRollout<Branch extends BranchBasicInfo> = LegacyRollout<Branch> & {
+    runtimeVersion: string;
+};
+type LegacyRollout<Branch extends BranchBasicInfo> = {
+    rolledOutBranch: Branch;
+    defaultBranch: Branch;
+} & LegacyRolloutInfo;
+type ConstrainedRolloutInfo = LegacyRolloutInfo & {
+    runtimeVersion: string;
+};
+type LegacyRolloutInfo = {
+    rolledOutBranchId: string;
+    percentRolledOut: number;
+    defaultBranchId: string;
+};
+export type RolloutBranchMapping = LegacyRolloutBranchMapping | ConstrainedRolloutBranchMapping;
+type RolloutNode = {
+    clientKey: 'rolloutToken';
+    branchMappingOperator: 'hash_lt';
+    operand: number;
+};
+type RuntimeVersionNode = {
+    clientKey: 'runtimeVersion';
+    branchMappingOperator: '==';
+    operand: string;
+};
+type RtvConstrainedRolloutNode = ['and', RolloutNode, RuntimeVersionNode] | ['and', RuntimeVersionNode, RolloutNode];
+export type LegacyRolloutBranchMapping = {
+    version: number;
+    data: [
+        {
+            branchId: string;
+            branchMappingLogic: RolloutNode;
+        },
+        {
+            branchId: string;
+            branchMappingLogic: BranchMappingAlwaysTrue;
+        }
+    ];
+};
+export type ConstrainedRolloutBranchMapping = {
+    version: number;
+    data: [
+        {
+            branchId: string;
+            branchMappingLogic: RtvConstrainedRolloutNode;
+        },
+        {
+            branchId: string;
+            branchMappingLogic: BranchMappingAlwaysTrue;
+        }
+    ];
+};
+export declare function isLegacyRolloutInfo(rollout: RolloutInfo): rollout is LegacyRolloutInfo;
+export declare function isConstrainedRolloutInfo(rollout: RolloutInfo): rollout is ConstrainedRolloutInfo;
+export declare function isConstrainedRollout<Branch extends BranchBasicInfo>(rollout: Rollout<Branch>): rollout is ConstrainedRollout<Branch>;
+export declare function getRolloutInfo(basicChannelInfo: ChannelBasicInfo): RolloutInfo;
+export declare function getRolloutInfoFromBranchMapping(branchMapping: RolloutBranchMapping): RolloutInfo;
+export declare function getRollout<Branch extends BranchBasicInfo>(channel: UpdateChannelInfoWithBranches<Branch>): Rollout<Branch>;
+export declare function composeRollout<Branch extends BranchBasicInfo>(rolloutInfo: RolloutInfo, defaultBranch: Branch, rolledOutBranch: Branch): Rollout<Branch>;
+export declare function getRolloutBranchMapping(branchMappingString: string): RolloutBranchMapping;
+/**
+ * Detect if a branch mapping is a rollout.
+ *
+ * Types of rollout:
+ * 1. Legacy unconstrained rollout:
+ * Maps to a rollout branch via a rollout token
+ * Falls back to a default branch
+ *
+ * Example:
+ * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: {
+          operand: 10 / 100,
+          clientKey: 'rolloutToken',
+          branchMappingOperator: hashLtOperator(),
+        },
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+  *
+  * 2. RTV constrained rollout:
+  * Maps to a rollout branch via a rollout token, constrained by runtime version
+  * Falls back to a default branch
+  *
+  * Example:
+  * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: andStatement([
+          {
+            operand: '1.0.0',
+            clientKey: 'runtimeVersion',
+            branchMappingOperator: equalsOperator(),
+          },
+          {
+            operand: 10 / 100,
+            clientKey: 'rolloutToken',
+            branchMappingOperator: hashLtOperator(),
+          },
+        ]),
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+ */
+export declare function isRolloutBranchMapping(branchMapping: BranchMapping): branchMapping is RolloutBranchMapping;
+export declare function isRollout(channelInfo: ChannelBasicInfo): boolean;
+export declare function doesTargetRollout(branchMapping: RolloutBranchMapping, runtimeVersion: string): boolean;
+export declare function createRolloutBranchMapping({ defaultBranchId, rolloutBranchId, percent, runtimeVersion, }: {
+    defaultBranchId: string;
+    rolloutBranchId: string;
+    percent: number;
+    runtimeVersion: string;
+}): ConstrainedRolloutBranchMapping;
+export declare function editRolloutBranchMapping(branchMapping: RolloutBranchMapping, percent: number): RolloutBranchMapping;
+export declare function assertRolloutBranchMapping(branchMapping: BranchMapping): asserts branchMapping is RolloutBranchMapping;
+export {};