eas-cli 3.17.1 → 3.18.1

package/build/rollout/actions/NonInteractiveRollout.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonInteractiveRollout = void 0;
+const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
+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");
+/**
+ * Control a rollout in non interactive mode.
+ */
+class NonInteractiveRollout {
+    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,
+        });
+        if (!action) {
+            throw new Error(`--action is required in non-interactive mode.`);
+        }
+        await this.runActionAsync(ctx, action, channelInfo, this.options);
+    }
+    async runActionAsync(ctx, action, channelInfo, options) {
+        switch (action) {
+            case RolloutMainMenu_1.MainMenuActions.CREATE_NEW:
+                return await new CreateRollout_1.CreateRollout(channelInfo, options).runAsync(ctx);
+            case ManageRollout_1.ManageRolloutActions.EDIT:
+                return await new EditRollout_1.EditRollout(channelInfo, options).runAsync(ctx);
+            case ManageRollout_1.ManageRolloutActions.END:
+                return await new EndRollout_1.EndRollout(channelInfo, options).runAsync(ctx);
+        }
+    }
+}
+exports.NonInteractiveRollout = NonInteractiveRollout;

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

@@ -0,0 +1,28 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+import { NonInteractiveOptions as CreateRolloutNonInteractiveOptions } from './CreateRollout';
+import { NonInteractiveOptions as EditRolloutNonInteractiveOptions } from './EditRollout';
+import { NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
+import { ManageRolloutActions } from './ManageRollout';
+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;
+/**
+ * Manage a rollout for the project.
+ */
+export declare class RolloutMainMenu implements EASUpdateAction<void> {
+    private options;
+    constructor(options?: {
+        channelName?: string;
+        action?: RolloutActions;
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & Partial<CreateRolloutNonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<void>;
+    runActionAsync(ctx: EASUpdateContext, menuAction: MainMenuActions): Promise<null>;
+    selectRolloutAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment | null>;
+    selectChannelAsync(ctx: EASUpdateContext, filterPredicate?: (channelInfo: UpdateChannelBasicInfoFragment) => boolean): Promise<UpdateChannelBasicInfoFragment>;
+    resolveChannelNameAsync(ctx: EASUpdateContext, channelName: string): Promise<UpdateChannelBasicInfoFragment>;
+    toMainMenuAction(action: RolloutActions): MainMenuActions;
+    promptMenuActionAsync(): Promise<MainMenuActions>;
+}

package/build/rollout/actions/RolloutMainMenu.js

@@ -0,0 +1,110 @@
+"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 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");
+const CreateRollout_1 = require("./CreateRollout");
+const ManageRollout_1 = require("./ManageRollout");
+const SelectRollout_1 = require("./SelectRollout");
+var MainMenuActions;
+(function (MainMenuActions) {
+    MainMenuActions["CREATE_NEW"] = "Create a new rollout";
+    MainMenuActions["MANAGE_EXISTING"] = "Manage an existing rollout";
+})(MainMenuActions = exports.MainMenuActions || (exports.MainMenuActions = {}));
+/**
+ * Manage a rollout for the project.
+ */
+class RolloutMainMenu {
+    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.selectChannelAsync(ctx, channelInfo => !(0, branch_mapping_1.isRollout)(channelInfo));
+                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 selectChannelAsync(ctx, filterPredicate) {
+        const selectChannelAction = new SelectChannel_1.SelectChannel({ filterPredicate });
+        const channelInfo = await selectChannelAction.runAsync(ctx);
+        if (!channelInfo) {
+            throw new Error(`You dont have any channels. Create one with <TODO>`);
+        }
+        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) {
+            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,36 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { RuntimeFragment, UpdateBranchBasicInfoFragment } from '../../graphql/generated';
+import { Connection } from '../../utils/relay';
+/**
+ * Select a runtime from a branch
+ */
+export declare class SelectRuntime implements EASUpdateAction<string> {
+    private branchInfo;
+    private options;
+    private printedType;
+    constructor(branchInfo: UpdateBranchBasicInfoFragment, options?: {
+        anotherBranchToIntersectRuntimesBy?: UpdateBranchBasicInfoFragment;
+    });
+    warnNoRuntime(): void;
+    formatCantFindRuntime(): string;
+    runAsync(ctx: EASUpdateContext): Promise<string>;
+    getNewestRuntimeAsync(graphqlClient: ExpoGraphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, }: {
+        appId: string;
+        branchName: string;
+        anotherBranchIdToIntersectRuntimesBy?: string;
+    }): Promise<Connection<RuntimeFragment> | null>;
+    displayLatestUpdateGroupAsync({ graphqlClient, appId, branchName, runtime, }: {
+        graphqlClient: ExpoGraphqlClient;
+        appId: string;
+        branchName: string;
+        runtime: RuntimeFragment;
+    }): Promise<string>;
+    selectRuntimesAsync(graphqlClient: ExpoGraphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, batchSize, }: {
+        appId: string;
+        branchName: string;
+        anotherBranchIdToIntersectRuntimesBy?: string;
+        batchSize?: number;
+    }): Promise<RuntimeFragment | null>;
+    promptForRuntimeAsync(): Promise<string>;
+}

package/build/rollout/actions/SelectRuntime.js

@@ -0,0 +1,167 @@
+"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");
+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);
+}
+/**
+ * Select a runtime from a branch
+ */
+class SelectRuntime {
+    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.`);
+            // TODO(quin): write a learn more
+            log_1.default.warn(`Your updates could be misconfigured. ${(0, log_1.learnMore)('https://expo.fyi/todo')}`);
+        }
+        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/todo')}`;
+    }
+    async runAsync(ctx) {
+        var _a, _b;
+        const { nonInteractive, graphqlClient, app } = ctx;
+        const { projectId } = app;
+        if (nonInteractive) {
+            throw new utils_1.NonInteractiveError(`runtime selection cannot be run in non-interactive mode.`);
+        }
+        const newestRuntimeConnection = await this.getNewestRuntimeAsync(graphqlClient, {
+            appId: projectId,
+            branchName: this.branchInfo.name,
+            anotherBranchIdToIntersectRuntimesBy: (_a = this.options.anotherBranchToIntersectRuntimesBy) === null || _a === void 0 ? void 0 : _a.id,
+        });
+        if (!newestRuntimeConnection) {
+            log_1.default.addNewLineIfNone();
+            this.warnNoRuntime();
+            return await this.promptForRuntimeAsync();
+        }
+        const moreThanOneRuntime = newestRuntimeConnection.edges.length > 1;
+        log_1.default.log(`✅ ${beginSentence(this.printedType)}${moreThanOneRuntime ? 's' : ''} detected`);
+        if (!moreThanOneRuntime) {
+            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 await this.promptForRuntimeAsync();
+            }
+        }
+        log_1.default.log(this.formatCantFindRuntime());
+        const selectedRuntime = await this.selectRuntimesAsync(graphqlClient, {
+            appId: projectId,
+            branchName: this.branchInfo.name,
+            anotherBranchIdToIntersectRuntimesBy: (_b = this.options.anotherBranchToIntersectRuntimesBy) === null || _b === void 0 ? void 0 : _b.id,
+        });
+        if (!selectedRuntime) {
+            throw new Error(`No ${this.printedType} selected`);
+        }
+        return selectedRuntime.version;
+    }
+    async getNewestRuntimeAsync(graphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, }) {
+        const connection = await RuntimeQuery_1.RuntimeQuery.getRuntimesOnBranchAsync(graphqlClient, {
+            appId,
+            name: branchName,
+            first: 1,
+            filter: {
+                branchId: anotherBranchIdToIntersectRuntimesBy,
+            },
+        });
+        const { edges } = connection;
+        if (edges.length === 0) {
+            return null;
+        }
+        return connection;
+    }
+    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);
+    }
+    async selectRuntimesAsync(graphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, batchSize = 5, }) {
+        const queryAsync = async (queryParams) => {
+            return await RuntimeQuery_1.RuntimeQuery.getRuntimesOnBranchAsync(graphqlClient, {
+                appId,
+                name: branchName,
+                first: queryParams.first,
+                after: queryParams.after,
+                last: queryParams.last,
+                before: queryParams.before,
+                filter: {
+                    branchId: anotherBranchIdToIntersectRuntimesBy,
+                },
+            });
+        };
+        const getTitleAsync = async (runtime) => {
+            return await this.displayLatestUpdateGroupAsync({
+                graphqlClient,
+                appId,
+                branchName,
+                runtime,
+            });
+        };
+        return await (0, relay_1.selectPaginatedAsync)({
+            queryAsync,
+            getTitleAsync,
+            printedType: 'target runtime',
+            pageSize: batchSize,
+        });
+    }
+    async promptForRuntimeAsync() {
+        log_1.default.log(`You can input a runtime manually then publish an update later.`);
+        const { runtimeVersion } = await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'runtimeVersion',
+            message: 'Input a runtime version:',
+            initial: '1.0.0',
+        });
+        return runtimeVersion;
+    }
+}
+exports.SelectRuntime = SelectRuntime;

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

@@ -0,0 +1,128 @@
+import { BranchMapping, BranchMappingAlwaysTrue } from '../channel/branch-mapping';
+import { UpdateChannelBasicInfoFragment } from '../graphql/generated';
+import { UpdateBranchObject, UpdateChannelObject } from '../graphql/queries/ChannelQuery';
+export type Rollout = LegacyRollout | ConstrainedRollout;
+export type RolloutInfo = LegacyRolloutInfo | ConstrainedRolloutInfo;
+type ConstrainedRollout = LegacyRollout & {
+    runtimeVersion: string;
+};
+type LegacyRollout = {
+    rolledOutBranch: UpdateBranchObject;
+    defaultBranch: UpdateBranchObject;
+} & 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(rollout: Rollout): rollout is ConstrainedRollout;
+export declare function getRolloutInfo(basicChannelInfo: UpdateChannelBasicInfoFragment): RolloutInfo;
+export declare function getRolloutInfoFromBranchMapping(branchMapping: RolloutBranchMapping): RolloutInfo;
+export declare function getRollout(channel: UpdateChannelObject): Rollout;
+export declare function composeRollout(rolloutInfo: RolloutInfo, defaultBranch: UpdateBranchObject, rolledOutBranch: UpdateBranchObject): Rollout;
+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: UpdateChannelBasicInfoFragment): 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 {};