@payloadcms/figma 0.0.1-alpha.5 → 0.0.1-alpha.50

package/dist/utils/env-management.d.ts

@@ -1,16 +1,25 @@
 /**
- * Generate a cryptographically secure secret for PAYLOAD_SECRET
+ * Get an environment variable value from .env file (async)
  *
- * @returns 24-character hexadecimal string
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
  */
-export declare function generateSecret(): string;
+export declare function getEnvVar(projectPath: string, key: string): Promise<null | string>;
 /**
- * Manage environment files for a new project
+ * Get an environment variable value from .env file (sync)
  *
- * Creates .env from .env.example (if exists) and populates PAYLOAD_SECRET
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
+ */
+export declare function getEnvVarSync(projectPath: string, key: string): null | string;
+/**
+ * Add or update an environment variable in .env file
  *
  * @param projectPath - Path to project directory
- * @returns The generated payload secret
+ * @param key - Environment variable name
+ * @param value - Environment variable value
  */
-export declare function manageEnvFiles(projectPath: string): Promise<string>;
+export declare function addOrUpdateEnvVar(projectPath: string, key: string, value: string): Promise<void>;
 //# sourceMappingURL=env-management.d.ts.map

package/dist/utils/env-management.js

@@ -1,97 +1,118 @@
-import { randomBytes } from 'crypto';
 import fs from 'fs/promises';
+import fsSync from 'node:fs';
 import path from 'path';
 /**
- * Generate a cryptographically secure secret for PAYLOAD_SECRET
- *
- * @returns 24-character hexadecimal string
- */ export function generateSecret() {
-    return randomBytes(32).toString('hex').slice(0, 24);
-}
-/**
- * Sanitize and process environment file contents
- *
- * @param contents - Raw .env file contents
- * @param payloadSecret - Secret to use for PAYLOAD_SECRET
- * @returns Processed .env contents
- */ function sanitizeEnv(contents, payloadSecret) {
-    const lines = contents.split('\n');
-    const seenKeys = new Set();
-    const processedLines = [];
+ * Parse .env file contents and extract value for a key
+ */ function parseEnvValue(contents, key) {
+    const lines = contents.split(/\r?\n/);
     for (const line of lines){
         // Skip empty lines and comments
         if (!line.trim() || line.trim().startsWith('#')) {
-            processedLines.push(line);
             continue;
         }
         // Skip lines without =
         if (!line.includes('=')) {
-            processedLines.push(line);
             continue;
         }
-        const [key] = line.split('=');
-        const trimmedKey = key.trim();
-        // Skip duplicate keys
-        if (seenKeys.has(trimmedKey)) {
-            continue;
-        }
-        seenKeys.add(trimmedKey);
-        // Replace PAYLOAD_SECRET with actual value
-        if (trimmedKey === 'PAYLOAD_SECRET' || trimmedKey === 'PAYLOAD_SECRET_KEY') {
-            processedLines.push(`PAYLOAD_SECRET=${payloadSecret}`);
-        } else {
-            processedLines.push(line);
+        const equalsIndex = line.indexOf('=');
+        const lineKey = line.substring(0, equalsIndex).trim();
+        if (lineKey === key) {
+            return line.substring(equalsIndex + 1);
         }
     }
-    // Add PAYLOAD_SECRET if not present
-    if (!seenKeys.has('PAYLOAD_SECRET') && !seenKeys.has('PAYLOAD_SECRET_KEY')) {
-        processedLines.push(`PAYLOAD_SECRET=${payloadSecret}`);
+    return null;
+}
+/**
+ * Get an environment variable value from .env file (async)
+ *
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
+ */ export async function getEnvVar(projectPath, key) {
+    const envPath = path.join(projectPath, '.env');
+    try {
+        const contents = await fs.readFile(envPath, 'utf-8');
+        return parseEnvValue(contents, key);
+    } catch  {
+        // File doesn't exist or can't be read
+        return null;
     }
-    return processedLines.join('\n');
 }
 /**
- * Manage environment files for a new project
+ * Get an environment variable value from .env file (sync)
  *
- * Creates .env from .env.example (if exists) and populates PAYLOAD_SECRET
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
+ */ export function getEnvVarSync(projectPath, key) {
+    const envPath = path.join(projectPath, '.env');
+    try {
+        const contents = fsSync.readFileSync(envPath, 'utf-8');
+        return parseEnvValue(contents, key);
+    } catch  {
+        // File doesn't exist or can't be read
+        return null;
+    }
+}
+/**
+ * Add or update an environment variable in .env file
  *
  * @param projectPath - Path to project directory
- * @returns The generated payload secret
- */ export async function manageEnvFiles(projectPath) {
-    const payloadSecret = generateSecret();
-    const envExamplePath = path.join(projectPath, '.env.example');
+ * @param key - Environment variable name
+ * @param value - Environment variable value
+ */ export async function addOrUpdateEnvVar(projectPath, key, value) {
     const envPath = path.join(projectPath, '.env');
     try {
-        // Check if .env.example exists
-        let envExampleContents = '';
-        try {
-            envExampleContents = await fs.readFile(envExamplePath, 'utf-8');
-        } catch  {
-            // No .env.example, create minimal .env
-            envExampleContents = '';
-        }
-        // Check if .env already exists
+        let contents = '';
         let envExists = false;
+        // Try to read existing .env file
         try {
-            await fs.access(envPath);
+            contents = await fs.readFile(envPath, 'utf-8');
             envExists = true;
         } catch  {
-        // .env doesn't exist
+        // .env doesn't exist, will create it
         }
-        if (!envExists) {
-            // Create .env from .env.example
-            const sanitized = sanitizeEnv(envExampleContents, payloadSecret);
-            await fs.writeFile(envPath, sanitized, 'utf-8');
-        } else {
-            // Update existing .env if it doesn't have PAYLOAD_SECRET
-            const existingContents = await fs.readFile(envPath, 'utf-8');
-            if (!existingContents.includes('PAYLOAD_SECRET=') && !existingContents.includes('PAYLOAD_SECRET_KEY=')) {
-                const sanitized = sanitizeEnv(existingContents, payloadSecret);
-                await fs.writeFile(envPath, sanitized, 'utf-8');
+        const lines = contents.split(/\r?\n/);
+        const seenKeys = new Set();
+        const processedLines = [];
+        let keyUpdated = false;
+        for (const line of lines){
+            // Skip empty lines at start if file didn't exist
+            if (!envExists && !line.trim()) {
+                continue;
+            }
+            // Preserve empty lines and comments
+            if (!line.trim() || line.trim().startsWith('#')) {
+                processedLines.push(line);
+                continue;
+            }
+            // Skip lines without =
+            if (!line.includes('=')) {
+                processedLines.push(line);
+                continue;
             }
+            const [lineKey] = line.split('=');
+            const trimmedKey = lineKey.trim();
+            // Skip duplicate keys (keep first occurrence)
+            if (seenKeys.has(trimmedKey)) {
+                continue;
+            }
+            seenKeys.add(trimmedKey);
+            // Update or keep the line
+            if (trimmedKey === key) {
+                processedLines.push(`${key}=${value}`);
+                keyUpdated = true;
+            } else {
+                processedLines.push(line);
+            }
+        }
+        // Add key if not present
+        if (!keyUpdated) {
+            processedLines.push(`${key}=${value}`);
         }
-        return payloadSecret;
+        await fs.writeFile(envPath, processedLines.join('\n'), 'utf-8');
     } catch (error) {
-        throw new Error(`Failed to manage environment files: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw new Error(`Failed to update .env file: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
 

package/dist/utils/format-env-suffix.d.ts

@@ -0,0 +1,12 @@
+import type { Environment } from '../constants.js';
+/**
+ * Format environment suffix for user-facing messages.
+ * Returns empty string for production (default), suffix for other environments.
+ *
+ * @param env - The environment
+ * @param prefix - Prefix before environment name (default: ' to ')
+ * @param suffix - Suffix after environment name (default: '')
+ * @returns Formatted string or empty string for production
+ */
+export declare function formatEnvSuffix(env: Environment, prefix?: string, suffix?: string): string;
+//# sourceMappingURL=format-env-suffix.d.ts.map

package/dist/utils/format-env-suffix.js

@@ -0,0 +1,13 @@
+/**
+ * Format environment suffix for user-facing messages.
+ * Returns empty string for production (default), suffix for other environments.
+ *
+ * @param env - The environment
+ * @param prefix - Prefix before environment name (default: ' to ')
+ * @param suffix - Suffix after environment name (default: '')
+ * @returns Formatted string or empty string for production
+ */ export function formatEnvSuffix(env, prefix = ' to ', suffix = '') {
+    return env !== 'production' ? `${prefix}${env}${suffix}` : '';
+}
+
+//# sourceMappingURL=format-env-suffix.js.map

package/dist/utils/formatter.js

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import spawn from 'cross-spawn';
 import path from 'path';
 /**
  * Format file with Prettier
@@ -6,15 +6,13 @@ import path from 'path';
  */ export async function formatFile(filePath, packageManager) {
     return new Promise((resolve)=>{
         try {
-            const args = [
+            const child = spawn(packageManager, [
                 'exec',
                 'prettier',
                 '--write',
                 filePath
-            ];
-            const child = spawn(packageManager, args, {
+            ], {
                 cwd: path.dirname(filePath),
-                shell: true,
                 stdio: 'pipe'
             });
             child.on('close', (code)=>{

package/dist/utils/lambda-config.d.ts

@@ -1,7 +1,9 @@
+import type { PackageManager } from './package-manager.js';
 /**
  * Apply Lambda-specific modifications to a Payload project
  *
  * @param projectPath - Path to project directory
+ * @param packageManager - Package manager to use in scripts (defaults to 'npm')
  */
-export declare function applyLambdaModifications(projectPath: string): Promise<void>;
+export declare function applyLambdaModifications(projectPath: string, packageManager?: PackageManager): Promise<void>;
 //# sourceMappingURL=lambda-config.d.ts.map

package/dist/utils/lambda-config.js

@@ -7,30 +7,19 @@ const RUN_SH_CONTENT = `#!/bin/bash -x
 
 NODE_ENV=production exec node server.js
 `;
-const BUILD_FOR_LAMBDA_SH_CONTENT = `#!/bin/bash
-
-cp -r .next/static .next/standalone/.next/static
-cp run.sh .next/standalone/run.sh
-cd .next/standalone
-zip -r --symlinks lambda.zip .
-mv lambda.zip ../..
-`;
 /**
  * Apply Lambda-specific modifications to a Payload project
  *
  * @param projectPath - Path to project directory
- */ export async function applyLambdaModifications(projectPath) {
+ * @param packageManager - Package manager to use in scripts (defaults to 'npm')
+ */ export async function applyLambdaModifications(projectPath, packageManager = 'npm') {
     // 1. Create run.sh
     const runShPath = path.join(projectPath, 'run.sh');
     await fs.writeFile(runShPath, RUN_SH_CONTENT, 'utf-8');
-    await fs.chmod(runShPath, 0o755); // rwxr-xr-x
-    // 2. Create build_for_lambda.sh
-    const buildShPath = path.join(projectPath, 'build_for_lambda.sh');
-    await fs.writeFile(buildShPath, BUILD_FOR_LAMBDA_SH_CONTENT, 'utf-8');
-    await fs.chmod(buildShPath, 0o755);
-    // 3. Modify next config to add standalone output
-    await addStandaloneToNextConfig(projectPath);
-    // 4. Create/update .npmrc
+    await fs.chmod(runShPath, 0o755);
+    // 2. Modify next config to add standalone output and eslint ignore
+    await addNextConfigProperties(projectPath);
+    // 3. Create/update .npmrc
     const npmrcPath = path.join(projectPath, '.npmrc');
     let npmrcContent = '';
     try {
@@ -43,8 +32,8 @@ mv lambda.zip ../..
         npmrcContent += 'node-linker=hoisted\n';
         await fs.writeFile(npmrcPath, npmrcContent, 'utf-8');
     }
-    // 5. Add lambda:buildzip script to package.json
-    await addLambdaBuildScript(projectPath);
+    // 4. Add lambda:buildzip script to package.json
+    await addLambdaBuildScript(projectPath, packageManager);
 }
 /**
  * Find the Next.js config file (next.config.js or next.config.mjs)
@@ -67,13 +56,18 @@ mv lambda.zip ../..
     throw new Error('Could not find next.config.js or next.config.mjs');
 }
 /**
- * Add standalone output to Next.js config using AST parsing
- */ async function addStandaloneToNextConfig(projectPath) {
+ * Add required Next.js config properties using AST parsing
+ * - output: 'standalone' (for Lambda deployment)
+ * - eslint: { ignoreDuringBuilds: true } (allow builds with lint errors)
+ */ async function addNextConfigProperties(projectPath) {
     const nextConfigPath = await findNextConfigPath(projectPath);
     const content = await fs.readFile(nextConfigPath, 'utf-8');
-    // Check if output already configured (quick check before parsing)
-    if (content.includes('output:')) {
-        return; // Already configured
+    // Check which properties already exist
+    const hasOutput = content.includes('output:');
+    const hasEslint = content.includes('eslint:');
+    // Early exit if both already configured
+    if (hasOutput && hasEslint) {
+        return;
     }
     const ast = parseModule(content, {
         loc: true
@@ -114,30 +108,42 @@ mv lambda.zip ../..
         throw new Error(`Could not find Next.js config object in ${path.basename(nextConfigPath)}. ` + `Expected either 'export default { ... }' or 'export default wrapper(configVar, ...)'`);
     }
     const { loc } = targetObjectExpression;
-    const lines = content.split('\n');
-    // Insert output: 'standalone' as first property
+    const lines = content.split(/\r?\n/);
+    // Build insertion string based on what's missing
+    const parts = [];
+    if (!hasOutput) {
+        parts.push("output: 'standalone',");
+    }
+    if (!hasEslint) {
+        parts.push(`eslint: {
+    ignoreDuringBuilds: true,
+  },`);
+    }
+    const insertString = '\n  ' + parts.join('\n  ');
+    // Insert after opening brace
     const insertLine = loc.start.line - 1;
-    const insertColumn = loc.start.column + 1 // After opening brace
-    ;
-    // Find the content of the line with the opening brace
+    const insertColumn = loc.start.column + 1;
     const targetLine = lines[insertLine];
     if (!targetLine) {
         throw new Error(`Could not find target line in ${path.basename(nextConfigPath)}`);
     }
-    lines[insertLine] = targetLine.slice(0, insertColumn) + "\n  output: 'standalone'," + targetLine.slice(insertColumn);
+    lines[insertLine] = targetLine.slice(0, insertColumn) + insertString + targetLine.slice(insertColumn);
     const modifiedContent = lines.join('\n');
     await fs.writeFile(nextConfigPath, modifiedContent, 'utf-8');
 }
 /**
  * Add lambda:buildzip script to package.json
- */ async function addLambdaBuildScript(projectPath) {
+ */ async function addLambdaBuildScript(projectPath, packageManager) {
     const packageJsonPath = path.join(projectPath, 'package.json');
     const content = await fs.readFile(packageJsonPath, 'utf-8');
     const packageJson = JSON.parse(content);
     if (!packageJson.scripts) {
         packageJson.scripts = {};
     }
-    packageJson.scripts['lambda:buildzip'] = 'npm run build && ./build_for_lambda.sh';
+    // Use package manager's run and exec commands
+    const runCmd = packageManager === 'npm' ? 'npm run' : packageManager;
+    const execCmd = packageManager === 'npm' ? 'npx' : `${packageManager} exec`;
+    packageJson.scripts['lambda:buildzip'] = `${runCmd} build && ${execCmd} payloadcms-figma build-lambda-zip`;
     await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
 }
 

package/dist/utils/messages.d.ts

@@ -1,4 +1,4 @@
-import type { PackageManager } from '../types.js';
+import type { PackageManager } from './package-manager.js';
 export declare function helpMessage(): void;
 export declare function successMessage(projectDir: string, packageManager: PackageManager): string;
 export declare function successfulNextInit(): string;

package/dist/utils/messages.js

@@ -14,31 +14,45 @@ export function helpMessage() {
       ${pc.cyan('logout')}           Clear all stored tokens
       ${pc.cyan('list-tokens')}      Show stored token information
       ${pc.cyan('init')}             Initialize a Figma CMS project
+      ${pc.cyan('debug')}            Show debug info for troubleshooting
+      ${pc.cyan('env')}              Switch active environment
       ${pc.cyan('deploy')}           Deploy your project to Figma
+      ${pc.cyan('build-lambda-zip')} Build Lambda deployment zip
 
   ${pc.bold('OPTIONS')}
 
       ${pc.dim('-h, --help          Show help')}
+      ${pc.dim('-v, --version       Show CLI version')}
       ${pc.dim('--debug             Enable debug logging')}
 
   ${pc.bold('AUTHENTICATION')}
 
       ${pc.cyan('@payloadcms/figma login')}                Authenticate with Figma
-      ${pc.cyan('@payloadcms/figma logout')}               Clear all tokens (with confirmation)
+      ${pc.cyan('@payloadcms/figma logout')}               Clear tokens for current environment
       ${pc.cyan('@payloadcms/figma list-tokens')}          Display stored OAuth and project tokens
 
   ${pc.bold('INIT COMMAND')}
 
-      ${pc.cyan('@payloadcms/figma init --id <cms-id>')}   Initialize project with CMS ID
-      ${pc.cyan('@payloadcms/figma init')}                 Initialize (prompts for CMS ID)
-      ${pc.cyan('@payloadcms/figma init --name my-cms')}   Specify project name for new projects
-      ${pc.cyan('@payloadcms/figma init --force')}         Force reconfiguration of existing project
-      ${pc.cyan('@payloadcms/figma init --skip-auth')}     Skip authentication (testing only)
+      ${pc.cyan('@payloadcms/figma init --id <cms-resource-id>')}     Initialize project
+      ${pc.cyan('@payloadcms/figma init --id <id> --env staging')}    Initialize for specific environment
+      ${pc.dim('--force')}                               Force reconfiguration of existing project
+
+  ${pc.bold('ENV COMMAND')}
+
+      ${pc.cyan('@payloadcms/figma env')}                    List and switch environments
+      ${pc.cyan('@payloadcms/figma env production')}          Switch to a named environment
 
   ${pc.bold('DEPLOY COMMAND')}
 
-      ${pc.cyan('@payloadcms/figma deploy')}               Deploy your project to Figma
-      ${pc.dim('--yes, -y')}          Skip confirmation prompts
+      ${pc.cyan('@payloadcms/figma deploy')}             Deploy your project to Figma
+      ${pc.dim('--id <project-id>')}                     Override FIGMA_PROJECT_ID
+      ${pc.dim('--env <environment>')}                   Override FIGMA_ENVIRONMENT_NAME
+      ${pc.dim('--yes, -y')}                             Skip confirmation prompts
+      ${pc.dim('--skip-build')}                          Skip building and use existing build
+
+  ${pc.bold('GLOBAL OPTIONS')}
+
+      ${pc.dim('--infra-env <env>')}                     Target infrastructure (production or staging)
 
   ${pc.bold('DOCUMENTATION')}
 

package/dist/utils/package-manager.d.ts

@@ -9,4 +9,28 @@ export type PackageManager = 'npm' | 'pnpm' | 'yarn';
  * @returns Detected package manager, defaults to npm
  */
 export declare function getPackageManager(projectDir: string): Promise<PackageManager>;
+/**
+ * Resolve package manager for a project directory.
+ * Checks lockfiles first, falls back to environment detection.
+ *
+ * @param projectDir - Project directory to check
+ * @returns Resolved package manager
+ */
+export declare function resolvePackageManager(projectDir: string): Promise<PackageManager>;
+/**
+ * Detect package manager from npm_config_user_agent environment variable.
+ * Set automatically by npm/pnpm/yarn when running via npx/pnpm dlx/yarn dlx.
+ *
+ * @returns Detected package manager, defaults to npm
+ */
+export declare function detectPackageManagerFromEnvironment(): PackageManager;
+/**
+ * Get the run command prefix for a package manager.
+ * npm needs "npm run", pnpm/yarn can run scripts directly.
+ */
+export declare function getRunCommand(packageManager: PackageManager): string;
+/**
+ * Get the add/install command for a package manager.
+ */
+export declare function getAddCommand(packageManager: PackageManager): string;
 //# sourceMappingURL=package-manager.d.ts.map

package/dist/utils/package-manager.js

@@ -23,6 +23,59 @@ import path from 'path';
         return 'npm';
     }
 }
+/**
+ * Resolve package manager for a project directory.
+ * Checks lockfiles first, falls back to environment detection.
+ *
+ * @param projectDir - Project directory to check
+ * @returns Resolved package manager
+ */ export async function resolvePackageManager(projectDir) {
+    const fromLockfile = await getPackageManager(projectDir);
+    if (fromLockfile !== 'npm') {
+        return fromLockfile;
+    }
+    // Check if there's actually a package-lock.json (explicit npm choice)
+    if (await fileExists(path.join(projectDir, 'package-lock.json'))) {
+        return 'npm';
+    }
+    // No lockfile found — check environment
+    return detectPackageManagerFromEnvironment();
+}
+/**
+ * Detect package manager from npm_config_user_agent environment variable.
+ * Set automatically by npm/pnpm/yarn when running via npx/pnpm dlx/yarn dlx.
+ *
+ * @returns Detected package manager, defaults to npm
+ */ export function detectPackageManagerFromEnvironment() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (!userAgent) {
+        return 'npm';
+    }
+    if (userAgent.startsWith('pnpm/')) {
+        return 'pnpm';
+    }
+    if (userAgent.startsWith('yarn/')) {
+        return 'yarn';
+    }
+    return 'npm';
+}
+/**
+ * Get the run command prefix for a package manager.
+ * npm needs "npm run", pnpm/yarn can run scripts directly.
+ */ export function getRunCommand(packageManager) {
+    return packageManager === 'npm' ? 'npm run' : packageManager;
+}
+/**
+ * Get the add/install command for a package manager.
+ */ export function getAddCommand(packageManager) {
+    if (packageManager === 'npm') {
+        return 'npm install';
+    }
+    if (packageManager === 'pnpm') {
+        return 'pnpm add';
+    }
+    return 'yarn add';
+}
 /**
  * Check if file exists
  */ async function fileExists(filePath) {

package/dist/utils/payload-config-ast.d.ts

@@ -1,19 +1,39 @@
 import type { SourceFile } from 'ts-morph';
+/**
+ * Result of detecting what changes are needed in a payload config file
+ */
 export type DetectionResult = {
+    /** Database adapter configuration if present */
     dbProperty?: {
+        /** Name of the adapter function (e.g., 'mongooseAdapter', 'postgresAdapter') */
         adapter: string;
+        /** NPM package the adapter is imported from (e.g., '@payloadcms/db-mongodb') */
         importSource: string;
     };
+    /** Editor configuration if present */
     editorProperty?: {
+        /** NPM package the editor is imported from (e.g., '@payloadcms/richtext-lexical') */
         importSource: string;
+        /** Whether this is a default editor with no custom configuration */
         isDefault: boolean;
     };
+    /** Whether the config already has a `figma` property */
     figmaObjectExists: boolean;
+    /** Whether buildConfig/buildFigmaConfig uses an import alias (e.g., 'buildConfig as createConfig') */
     hasAlias: boolean;
+    /** Whether a buildConfig or buildFigmaConfig call was found (undefined if not checked) */
     hasBuildConfig?: boolean;
+    /** Whether there are other imports from 'payload' besides buildConfig (e.g., types) */
     hasOtherPayloadImports: boolean;
+    /** Whether the import needs to be changed from 'payload' to '@payloadcms/figma' */
     needsImportChange: boolean;
+    /** Whether a `secret` property exists in the config */
     secretProperty?: boolean;
+    /** Sharp configuration if present */
+    sharpProperty?: {
+        /** NPM package sharp is imported from (always 'sharp') */
+        importSource: string;
+    };
 };
 /**
  * Detect what changes are needed in the payload config file
@@ -29,9 +49,8 @@ export type ASTModificationResult = {
  */
 export declare function applyModifications(sourceFile: SourceFile, detection: DetectionResult): ASTModificationResult;
 export type FigmaPropertyConfig = {
-    region: string;
-    tenantId: string;
-    useContentSystem: boolean;
+    contentSystemId: string;
+    useContentSystem?: boolean;
 };
 /**
  * Add figma property to buildConfig if it doesn't exist