@todesktop/shared 7.191.0 → 7.192.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @todesktop/shared
 
+## 7.191.1
+
+### Patch Changes
+
+- 797f9cc: feat(mas): add `mas.minimumSystemVersion` config option
+
 ## 7.191.0
 
 ### Minor Changes

package/lib/{base.d.ts → cjs/base.d.ts}

@@ -156,6 +156,7 @@ export interface ToDesktopJson {
     mas?: {
         entitlements?: FilePath;
         entitlementsInherit?: FilePath;
+        minimumSystemVersion?: string;
         provisioningProfile?: FilePath;
         type?: 'development' | 'distribution';
         x64ArchFiles?: string;

package/lib/cjs/base.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsHSMCertType = exports.WindowsEVOnboardingProvider = exports.WindowsEVOnboardingSteps = void 0;
+var WindowsEVOnboardingSteps;
+(function (WindowsEVOnboardingSteps) {
+    WindowsEVOnboardingSteps["hasBeenVerified"] = "hasBeenVerified";
+    WindowsEVOnboardingSteps["hasChosenProvider"] = "hasChosenProvider";
+    WindowsEVOnboardingSteps["hasGeneratedCert"] = "hasGeneratedCert";
+    WindowsEVOnboardingSteps["hasOrderedCert"] = "hasOrderedCert";
+    WindowsEVOnboardingSteps["hasUploadedCert"] = "hasUploadedCert";
+})(WindowsEVOnboardingSteps || (exports.WindowsEVOnboardingSteps = WindowsEVOnboardingSteps = {}));
+var WindowsEVOnboardingProvider;
+(function (WindowsEVOnboardingProvider) {
+    WindowsEVOnboardingProvider["globalsign"] = "globalsign";
+    WindowsEVOnboardingProvider["other"] = "other";
+})(WindowsEVOnboardingProvider || (exports.WindowsEVOnboardingProvider = WindowsEVOnboardingProvider = {}));
+var WindowsHSMCertType;
+(function (WindowsHSMCertType) {
+    WindowsHSMCertType["azureTrustedSigning"] = "azureTrustedSigning";
+    WindowsHSMCertType["ev"] = "ev";
+    WindowsHSMCertType["file"] = "file";
+})(WindowsHSMCertType || (exports.WindowsHSMCertType = WindowsHSMCertType = {}));

package/lib/{desktopify.d.ts → cjs/desktopify.d.ts}

@@ -1,5 +1,6 @@
 import { Configuration, PackagerOptions, PublishOptions } from 'app-builder-lib';
 import { IApp2 } from './desktopify2';
+import { BreakpointPauseLease, BreakpointQueueEntry, CurrentBreakpointState } from './introspection/breakpoints';
 import { IApp } from './toDesktop';
 type appBuilderLib = PackagerOptions & PublishOptions;
 export interface IAppBuilderLib extends appBuilderLib {
@@ -92,6 +93,30 @@ export interface PlatformBuild {
     status: BuildStatus;
 }
 export type CIRunner = 'azure' | 'circle';
+export type IntrospectBreakpointStatus = 'error' | 'finished' | 'initializing' | 'paused' | 'ready' | 'resuming';
+export type IntrospectShellStatus = 'connected' | 'connecting' | 'disconnected' | 'error' | 'initializing' | 'ready';
+export interface IntrospectPlatformData {
+    breakpointQueue?: BreakpointQueueEntry[];
+    breakpointStatus: IntrospectBreakpointStatus;
+    connectedAt?: Date;
+    connectedUserId?: string;
+    createdAt: ISODate;
+    currentBreakpoint?: CurrentBreakpointState;
+    disconnectedAt?: Date;
+    enabled: boolean;
+    error?: string;
+    jtiExpiresAt?: Date;
+    pauseLease?: BreakpointPauseLease;
+    sessionJti?: string;
+    shellStatus: IntrospectShellStatus;
+    tunnelUrl?: string;
+    usedJti?: string;
+}
+export interface IntrospectData {
+    linux: IntrospectPlatformData;
+    mac: IntrospectPlatformData;
+    windows: IntrospectPlatformData;
+}
 export interface Build {
     appCustomDomain?: string;
     appName: string;
@@ -118,6 +143,7 @@ export interface Build {
     hash?: string;
     icon?: string;
     id: string;
+    introspect?: IntrospectData;
     isArtifactsPruned?: boolean;
     isBeingCancelled?: boolean;
     linux?: PlatformBuild;

package/lib/cjs/desktopify.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBuildCancellable = exports.isBuildRunning = exports.isCiBuildRunning = exports.isPlatformBuildRunning = exports.hasBuildKickedOff = exports.ManifestCategory = exports.AnalysisStatus = exports.BuildStatus = exports.PackageManager = exports.PlatformName = void 0;
+var PlatformName;
+(function (PlatformName) {
+    PlatformName["linux"] = "linux";
+    PlatformName["mac"] = "mac";
+    PlatformName["windows"] = "windows";
+})(PlatformName || (exports.PlatformName = PlatformName = {}));
+var PackageManager;
+(function (PackageManager) {
+    PackageManager["npm"] = "npm";
+    PackageManager["pnpm"] = "pnpm";
+    PackageManager["yarn"] = "yarn";
+})(PackageManager || (exports.PackageManager = PackageManager = {}));
+var BuildStatus;
+(function (BuildStatus) {
+    BuildStatus["building"] = "building";
+    BuildStatus["cancelled"] = "cancelled";
+    BuildStatus["failed"] = "failed";
+    BuildStatus["preparation"] = "preparation";
+    BuildStatus["queued"] = "queued";
+    BuildStatus["succeeded"] = "succeeded";
+})(BuildStatus || (exports.BuildStatus = BuildStatus = {}));
+var AnalysisStatus;
+(function (AnalysisStatus) {
+    AnalysisStatus["analyzing"] = "analyzing";
+    AnalysisStatus["done"] = "done";
+    AnalysisStatus["downloading"] = "downloading";
+    AnalysisStatus["error"] = "error";
+    AnalysisStatus["extracting"] = "extracting";
+    AnalysisStatus["initializing"] = "initializing";
+    AnalysisStatus["notStarted"] = "notStarted";
+})(AnalysisStatus || (exports.AnalysisStatus = AnalysisStatus = {}));
+var ManifestCategory;
+(function (ManifestCategory) {
+    ManifestCategory["buildStamped"] = "build-stamped";
+    ManifestCategory["primary"] = "primary";
+    ManifestCategory["versioned"] = "versioned";
+})(ManifestCategory || (exports.ManifestCategory = ManifestCategory = {}));
+const hasBuildKickedOff = (build) => {
+    if (!build) {
+        return false;
+    }
+    return build.status && build.status !== BuildStatus.preparation;
+};
+exports.hasBuildKickedOff = hasBuildKickedOff;
+const isPlatformBuildRunning = (platformBuild) => {
+    if (!platformBuild) {
+        return false;
+    }
+    return (!platformBuild.shouldSkip && // <-- Noteworthy
+        !['cancelled', 'succeeded'].includes(platformBuild.status) &&
+        (platformBuild.status !== 'failed' ||
+            platformBuild.numberOfAttemptedBuilds < 2));
+};
+exports.isPlatformBuildRunning = isPlatformBuildRunning;
+// NOTE: this relies on Firestore solely
+const isCiBuildRunning = (build) => {
+    if (!build) {
+        return false;
+    }
+    return (build.status === 'building' ||
+        (build.status === 'failed' &&
+            ['linux', 'mac', 'windows'].some((platform) => build.status === 'building' ||
+                (build.status === 'failed' &&
+                    (0, exports.isPlatformBuildRunning)(build[platform])))));
+};
+exports.isCiBuildRunning = isCiBuildRunning;
+const isBuildRunning = (build) => {
+    if (!build) {
+        return false;
+    }
+    return (!['cancelled', 'succeeded'].includes(build.status) &&
+        ['linux', 'mac', 'windows'].some((platform) => (0, exports.isPlatformBuildRunning)(build[platform])));
+};
+exports.isBuildRunning = isBuildRunning;
+const isBuildCancellable = (build) => (0, exports.hasBuildKickedOff)(build) && (0, exports.isBuildRunning)(build);
+exports.isBuildCancellable = isBuildCancellable;

package/lib/cjs/desktopify2.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowedWebPreferencesOptions = exports.allowedBrowserWindowConstructorOptions = void 0;
+/**
+ * Whitelist of allowed DesktopifyWindow Options.
+ * These attrs (if set) are passed to the `BrowserWindow` constructor
+ * when the window is created
+ */
+exports.allowedBrowserWindowConstructorOptions = [
+    'width',
+    'height',
+    // "x",
+    // "y",
+    'useContentSize',
+    'center',
+    'minWidth',
+    'minHeight',
+    'maxWidth',
+    'maxHeight',
+    'resizable',
+    'movable',
+    'minimizable',
+    'maximizable',
+    'closable',
+    'focusable',
+    'alwaysOnTop',
+    'fullscreen',
+    'fullscreenable',
+    'simpleFullscreen',
+    'skipTaskbar',
+    'kiosk',
+    'icon',
+    'paintWhenInitiallyHidden',
+    'frame',
+    'acceptFirstMouse',
+    'disableAutoHideCursor',
+    'autoHideMenuBar',
+    'enableLargerThanScreen',
+    'backgroundColor',
+    'hasShadow',
+    'opacity',
+    'darkTheme',
+    'transparent',
+    'visualEffectState',
+    'titleBarStyle',
+    'trafficLightPosition',
+    // "roundedCorners",
+    'thickFrame',
+    'type',
+    'vibrancy',
+    'zoomToPageWidth',
+    'tabbingIdentifier',
+    'webPreferences',
+    'titleBarOverlay',
+];
+/**
+ * Whitelist of allowed DesktopifyWindow Web Preferences Options.
+ * These attrs (if set) are passed to the webPreferences object in the `BrowserWindow` constructor
+ * when the window is created
+ */
+exports.allowedWebPreferencesOptions = [
+    'devTools',
+    'zoomFactor',
+    'textAreasAreResizable',
+    'scrollBounce',
+    'defaultFontFamily',
+    'defaultFontSize',
+    'defaultMonospaceFontSize',
+    'minimumFontSize',
+    'defaultEncoding',
+    'backgroundThrottling',
+    'offscreen',
+    'safeDialogs',
+    'safeDialogsMessage',
+    'navigateOnDragDrop',
+    'autoplayPolicy',
+    'disableHtmlFullscreenWindowResize',
+    'accessibleTitle',
+    'spellcheck',
+];

package/lib/cjs/getSiteInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/hsm.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAPIKeyNameFromHSM = exports.getCertificateNameFromHSM = void 0;
+exports.isMacTarget = isMacTarget;
+exports.isWindowsTarget = isWindowsTarget;
+function isMacTarget(type) {
+    return ['mac', 'mac-installer', 'mas', 'mas-dev', 'mas-installer'].includes(type);
+}
+function isWindowsTarget(type) {
+    return ['windows'].includes(type);
+}
+/**
+ * Files that are uploaded to HSM have a unique secretName that depends on the appId and target.
+ * This function returns the key name that is used for certificate files that have a `.p12` postfix.
+ *
+ * @param appId the application id
+ * @param target the target type
+ * @returns the name of the secret that is required for downloading the cert from HSM.
+ */
+const getCertificateNameFromHSM = (appId, target) => {
+    if (!isMacTarget(target) && !isWindowsTarget(target)) {
+        throw new Error(`Invalid target '${target}'. Only windows or mac certs are supported`);
+    }
+    return `todesktop-${appId}-${target}-cert`;
+};
+exports.getCertificateNameFromHSM = getCertificateNameFromHSM;
+/**
+ * Files that are uploaded to HSM have a unique secretName that depends on the appId and target.
+ * This function returns the key name that is used for key files that have a `.p8` postfix.
+ * Currently only used for mac notarization.
+ *
+ * @param appId the application id
+ * @param target the target type
+ * @returns the name of the secret that is required for downloading the cert from HSM.
+ */
+const getAPIKeyNameFromHSM = (appId, target) => {
+    if (!isMacTarget(target)) {
+        throw new Error(`Invalid target '${target}'. Only mac certs are supported`);
+    }
+    return `todesktop-${appId}-${target}-api-key`;
+};
+exports.getAPIKeyNameFromHSM = getAPIKeyNameFromHSM;

package/lib/cjs/index.d.ts

@@ -0,0 +1,12 @@
+export * from './base';
+export * from './desktopify';
+export * from './desktopify2';
+export * from './getSiteInfo';
+export * from './hsm';
+export * from './invitePermissionLabels';
+export * from './personalAccessTokens';
+export * from './plans';
+export * from './plugin';
+export * from './toDesktop';
+export * from './validations';
+export declare const schemaVersion: any;

package/lib/cjs/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaVersion = void 0;
+/* eslint-disable @typescript-eslint/no-require-imports */
+// CJS-specific entry point
+// Path is relative to lib/cjs/ output directory
+const packageJson = require('../../package.json');
+__exportStar(require("./base"), exports);
+__exportStar(require("./desktopify"), exports);
+__exportStar(require("./desktopify2"), exports);
+__exportStar(require("./getSiteInfo"), exports);
+__exportStar(require("./hsm"), exports);
+__exportStar(require("./invitePermissionLabels"), exports);
+__exportStar(require("./personalAccessTokens"), exports);
+__exportStar(require("./plans"), exports);
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./toDesktop"), exports);
+__exportStar(require("./validations"), exports);
+exports.schemaVersion = packageJson.version;

package/lib/cjs/introspection/__tests__/breakpoints.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const breakpoints_1 = require("../breakpoints");
+(0, vitest_1.describe)('isSameBreakpoint', () => {
+    (0, vitest_1.it)('matches identical phase breakpoints', () => {
+        (0, vitest_1.expect)((0, breakpoints_1.isSameBreakpoint)({ id: 'beforeInstall', type: 'phase' }, { id: 'beforeInstall', type: 'phase' })).toBe(true);
+    });
+    (0, vitest_1.it)('fails when breakpoint types differ', () => {
+        (0, vitest_1.expect)((0, breakpoints_1.isSameBreakpoint)({ id: 'beforeInstall', type: 'phase' }, { id: 'todesktop:beforeInstall', position: 'before', type: 'hook' })).toBe(false);
+    });
+    (0, vitest_1.it)('considers hook positions', () => {
+        (0, vitest_1.expect)((0, breakpoints_1.isSameBreakpoint)({ id: 'todesktop:beforeBuild', position: 'before', type: 'hook' }, { id: 'todesktop:beforeBuild', position: 'after', type: 'hook' })).toBe(false);
+    });
+    (0, vitest_1.it)('returns false when either side is undefined', () => {
+        (0, vitest_1.expect)((0, breakpoints_1.isSameBreakpoint)(undefined, { id: 'afterInstall', type: 'phase' })).toBe(false);
+    });
+});
+(0, vitest_1.describe)('cloneBreakpointQueue', () => {
+    (0, vitest_1.it)('produces a deep copy of the queue', () => {
+        const original = [
+            { hitAt: undefined, id: 'beforeInstall', type: 'phase' },
+            {
+                id: 'todesktop:afterPack',
+                position: 'after',
+                skipped: true,
+                type: 'hook',
+            },
+        ];
+        const copy = (0, breakpoints_1.cloneBreakpointQueue)(original);
+        (0, vitest_1.expect)(copy).toEqual(original);
+        (0, vitest_1.expect)(copy).not.toBe(original);
+        (0, vitest_1.expect)(copy[0]).not.toBe(original[0]);
+    });
+});
+(0, vitest_1.describe)('markQueueSkipped', () => {
+    (0, vitest_1.it)('marks the starting entry as skipped and adds fallback timestamps', () => {
+        const queue = [
+            { id: 'beforeInstall', type: 'phase' },
+            { id: 'afterInstall', type: 'phase' },
+        ];
+        const fallbackHitAt = '2024-01-01T00:00:00.000Z';
+        const updated = (0, breakpoints_1.markQueueSkipped)(queue, 0, { fallbackHitAt });
+        (0, vitest_1.expect)(updated[0]).toMatchObject({
+            hitAt: fallbackHitAt,
+            skipped: true,
+        });
+        (0, vitest_1.expect)(updated[1]).toMatchObject({ skipped: true });
+        (0, vitest_1.expect)(queue[0].skipped).toBeUndefined();
+    });
+    (0, vitest_1.it)('returns a cloned queue when index is out of bounds', () => {
+        const queue = [
+            { id: 'beforeInstall', type: 'phase' },
+        ];
+        const updated = (0, breakpoints_1.markQueueSkipped)(queue, 2);
+        (0, vitest_1.expect)(updated).toEqual(queue);
+        (0, vitest_1.expect)(updated).not.toBe(queue);
+    });
+});

package/lib/cjs/introspection/breakpoints.d.ts

@@ -0,0 +1,45 @@
+export declare const BREAKPOINT_DEFAULT_LEASE_MS: number;
+export declare const BREAKPOINT_RENEW_INCREMENT_MS: number;
+export declare const BREAKPOINT_MAX_REMAINING_MS: number;
+export type PhaseBreakpointId = 'afterInstall' | 'afterPack' | 'afterSourcePrep' | 'afterUpload' | 'beforeFinalize' | 'beforeInstall' | 'beforePack' | 'beforeUpload';
+export type HookBreakpointName = 'todesktop:afterPack' | 'todesktop:beforeBuild' | 'todesktop:beforeInstall';
+export type HookBreakpointPosition = 'after' | 'before';
+interface PhaseBreakpointConfig {
+    id: PhaseBreakpointId;
+    type: 'phase';
+}
+interface HookBreakpointConfig {
+    id: HookBreakpointName;
+    position: HookBreakpointPosition;
+    type: 'hook';
+}
+export type BreakpointConfig = HookBreakpointConfig | PhaseBreakpointConfig;
+export type BreakpointQueueEntry = {
+    autoResumed?: boolean;
+    hitAt?: string;
+    skipped?: boolean;
+} & BreakpointConfig;
+export interface BreakpointRenewal {
+    renewedAt: string;
+    renewedByUserId: string;
+}
+export type CurrentBreakpointState = {
+    createdAt: string;
+    expiresAt: string;
+    renewals?: BreakpointRenewal[];
+    resumedAt?: string;
+    resumedByUserId?: string;
+    skipped?: boolean;
+    wasAutoResumed?: boolean;
+} & BreakpointConfig;
+export interface BreakpointPauseLease {
+    createdAt: string;
+    createdByUserId: string;
+    defaultDurationMs: number;
+}
+export declare function isSameBreakpoint(a: BreakpointConfig | BreakpointQueueEntry | CurrentBreakpointState | undefined, b: BreakpointConfig | BreakpointQueueEntry | CurrentBreakpointState | undefined): boolean;
+export declare function cloneBreakpointQueue(queue?: null | ReadonlyArray<BreakpointQueueEntry>): BreakpointQueueEntry[];
+export declare function markQueueSkipped(queue: ReadonlyArray<BreakpointQueueEntry>, startIndex: number, options?: {
+    fallbackHitAt?: string;
+}): BreakpointQueueEntry[];
+export {};

package/lib/cjs/introspection/breakpoints.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BREAKPOINT_MAX_REMAINING_MS = exports.BREAKPOINT_RENEW_INCREMENT_MS = exports.BREAKPOINT_DEFAULT_LEASE_MS = void 0;
+exports.isSameBreakpoint = isSameBreakpoint;
+exports.cloneBreakpointQueue = cloneBreakpointQueue;
+exports.markQueueSkipped = markQueueSkipped;
+const MINUTE = 60 * 1000;
+exports.BREAKPOINT_DEFAULT_LEASE_MS = 20 * MINUTE; // 20 minutes
+exports.BREAKPOINT_RENEW_INCREMENT_MS = 10 * MINUTE; // 10 minutes
+exports.BREAKPOINT_MAX_REMAINING_MS = 20 * MINUTE; // 20 minutes
+function isSameBreakpoint(a, b) {
+    if (!a || !b) {
+        return false;
+    }
+    if (a.type !== b.type) {
+        return false;
+    }
+    if (a.id !== b.id) {
+        return false;
+    }
+    if (isHookBreakpointConfig(a) && isHookBreakpointConfig(b)) {
+        return a.position === b.position;
+    }
+    return true;
+}
+function isHookBreakpointConfig(config) {
+    return config.type === 'hook';
+}
+function cloneBreakpointQueue(queue) {
+    return Array.isArray(queue) ? queue.map((entry) => (Object.assign({}, entry))) : [];
+}
+function markQueueSkipped(queue, startIndex, options = {}) {
+    var _a;
+    const updated = cloneBreakpointQueue(queue);
+    const { fallbackHitAt } = options;
+    if (startIndex < 0 || startIndex >= updated.length) {
+        return updated;
+    }
+    const current = updated[startIndex];
+    const hitAt = (_a = current.hitAt) !== null && _a !== void 0 ? _a : fallbackHitAt;
+    updated[startIndex] = Object.assign(Object.assign(Object.assign({}, current), { skipped: true }), (hitAt ? { hitAt } : {}));
+    for (let i = startIndex + 1; i < updated.length; i += 1) {
+        if (!updated[i].hitAt) {
+            updated[i] = Object.assign(Object.assign({}, updated[i]), { skipped: true });
+        }
+    }
+    return updated;
+}

package/lib/cjs/invitePermissionLabels.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeInvitePermissions = exports.FULL_OWNER_PERMISSIONS = exports.formatInvitePermissionSummary = exports.INVITE_PERMISSION_LABELS = void 0;
+exports.INVITE_PERMISSION_LABELS = {
+    canBuild: 'Can build',
+    canManageBilling: 'Can manage billing',
+    canManageUsers: 'Can manage users',
+    canRelease: 'Can release',
+};
+const formatInvitePermissionSummary = (permissions) => {
+    const enabled = Object.entries(permissions)
+        .filter(([, value]) => value === true)
+        .map(([key]) => exports.INVITE_PERMISSION_LABELS[key]);
+    return enabled.join(', ');
+};
+exports.formatInvitePermissionSummary = formatInvitePermissionSummary;
+exports.FULL_OWNER_PERMISSIONS = {
+    canBuild: true,
+    canManageBilling: true,
+    canManageUsers: true,
+    canRelease: true,
+};
+const normalizeInvitePermissions = (permissions) => ({
+    canBuild: (permissions === null || permissions === void 0 ? void 0 : permissions.canBuild) === true,
+    canManageBilling: (permissions === null || permissions === void 0 ? void 0 : permissions.canManageBilling) === true,
+    canManageUsers: (permissions === null || permissions === void 0 ? void 0 : permissions.canManageUsers) === true,
+    canRelease: (permissions === null || permissions === void 0 ? void 0 : permissions.canRelease) === true,
+});
+exports.normalizeInvitePermissions = normalizeInvitePermissions;

package/lib/cjs/personalAccessTokens.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });