twenty-sdk 0.5.2 → 0.6.0

package/dist/cli/commands/app/app-dev.d.ts

@@ -2,25 +2,9 @@ export type AppDevOptions = {
     appPath?: string;
 };
 export declare class AppDevCommand {
-    private appPath;
     private orchestrator;
-    private manifestWatcher;
-    private logicFunctionsWatcher;
-    private frontComponentsWatcher;
-    private assetWatcher;
-    private dependencyWatcher;
-    private watchersStarted;
-    private uiStateManager;
     private unmountUI;
     close(): Promise<void>;
     execute(options: AppDevOptions): Promise<void>;
-    private cleanOutputDir;
-    private startManifestWatcher;
-    private handleWatcherRestarts;
-    private startFileWatchers;
-    private startLogicFunctionsWatcher;
-    private startFrontComponentsWatcher;
-    private startAssetWatcher;
-    private startDependencyWatcher;
     private setupGracefulShutdown;
 }

package/dist/cli/commands/app/app-typecheck.d.ts

@@ -0,0 +1,6 @@
+export type AppTypecheckOptions = {
+    appPath?: string;
+};
+export declare class AppTypecheckCommand {
+    execute(options: AppTypecheckOptions): Promise<void>;
+}

package/dist/cli/commands/app/app-uninstall.d.ts

@@ -1,7 +1,7 @@
-import { ApiResponse } from '../../utilities/api/api-response-type';
+import { type ApiResponse } from '../../../cli/utilities/api/api-response-type';
 export declare class AppUninstallCommand {
     private apiService;
-    execute({ appPath, askForConfirmation, }: {
+    execute({ appPath, askForConfirmation }: {
         appPath?: string;
         askForConfirmation: boolean;
     }): Promise<ApiResponse<any>>;

package/dist/cli/commands/app-command.d.ts

@@ -1,2 +1,2 @@
-import { Command } from 'commander';
+import type { Command } from 'commander';
 export declare const registerCommands: (program: Command) => void;

package/dist/cli/commands/entity/entity-add.d.ts

@@ -1,12 +1,15 @@
 import { SyncableEntity } from 'twenty-shared/application';
 export declare class EntityAddCommand {
+    private lastObjectUniversalIdentifier;
     execute(entityType?: SyncableEntity, path?: string): Promise<void>;
     private getEntityData;
+    private promptAndCreateViewAndNavigationMenuItem;
     private getEntity;
     private handleFileExist;
     private getEntityName;
     private getFieldData;
     private getObjectData;
+    private getViewData;
     getFolderName(entity: SyncableEntity): string;
     getFileName(name: string, entity: SyncableEntity): string;
 }

package/dist/cli/commands/logic-function/logic-function-execute.d.ts

@@ -1,7 +1,8 @@
 export declare class LogicFunctionExecuteCommand {
     private apiService;
-    execute({ appPath, functionUniversalIdentifier, functionName, payload, }: {
+    execute({ appPath, postInstall, functionUniversalIdentifier, functionName, payload }: {
         appPath?: string;
+        postInstall?: boolean;
         functionUniversalIdentifier?: string;
         functionName?: string;
         payload?: string;

package/dist/cli/commands/logic-function/logic-function-logs.d.ts

@@ -1,6 +1,6 @@
 export declare class LogicFunctionLogsCommand {
     private apiService;
-    execute({ appPath, functionUniversalIdentifier, functionName, }: {
+    execute({ appPath, functionUniversalIdentifier, functionName }: {
         appPath?: string;
         functionUniversalIdentifier?: string;
         functionName?: string;

package/dist/cli/utilities/api/api-service.d.ts

@@ -1,6 +1,6 @@
-import { ApplicationManifest, Manifest } from 'twenty-shared/application';
-import { FileFolder } from 'twenty-shared/types';
-import { ApiResponse } from './api-response-type';
+import { type Manifest } from 'twenty-shared/application';
+import { type FileFolder } from 'twenty-shared/types';
+import { type ApiResponse } from '../../../cli/utilities/api/api-response-type';
 export declare class ApiService {
     private client;
     private configService;
@@ -11,18 +11,46 @@ export declare class ApiService {
         authValid: boolean;
         serverUp: boolean;
     }>;
-    checkApplicationExist(universalIdentifier: string): Promise<ApiResponse<boolean>>;
-    createApplication(manifest: Manifest): Promise<ApiResponse<ApplicationManifest>>;
+    findOneApplication(universalIdentifier: string): Promise<ApiResponse<{
+        id: string;
+        universalIdentifier: string;
+    } | null>>;
+    generateApplicationToken(applicationId: string): Promise<ApiResponse<{
+        applicationAccessToken: {
+            token: string;
+            expiresAt: string;
+        };
+        applicationRefreshToken: {
+            token: string;
+            expiresAt: string;
+        };
+    }>>;
+    renewApplicationToken(applicationRefreshToken: string): Promise<ApiResponse<{
+        applicationAccessToken: {
+            token: string;
+            expiresAt: string;
+        };
+        applicationRefreshToken: {
+            token: string;
+            expiresAt: string;
+        };
+    }>>;
+    createApplication(manifest: Manifest): Promise<ApiResponse<{
+        id: string;
+        universalIdentifier: string;
+    }>>;
     syncApplication(manifest: Manifest): Promise<ApiResponse>;
     uninstallApplication(universalIdentifier: string): Promise<ApiResponse>;
-    getSchema(): Promise<ApiResponse<string>>;
+    getSchema(options?: {
+        authToken?: string;
+    }): Promise<ApiResponse<string>>;
     findLogicFunctions(): Promise<ApiResponse<Array<{
         id: string;
         name: string;
         universalIdentifier: string;
         applicationId: string | null;
     }>>>;
-    executeLogicFunction({ functionId, payload, }: {
+    executeLogicFunction({ functionId, payload }: {
         functionId: string;
         payload: Record<string, unknown>;
     }): Promise<ApiResponse<{
@@ -36,12 +64,12 @@ export declare class ApiService {
             stackTrace: string;
         };
     }>>;
-    subscribeToLogs({ applicationUniversalIdentifier, functionUniversalIdentifier, functionName, }: {
+    subscribeToLogs({ applicationUniversalIdentifier, functionUniversalIdentifier, functionName }: {
         applicationUniversalIdentifier: string;
         functionUniversalIdentifier?: string;
         functionName?: string;
     }): Promise<void>;
-    uploadFile({ filePath, builtHandlerPath, fileFolder, applicationUniversalIdentifier, }: {
+    uploadFile({ filePath, builtHandlerPath, fileFolder, applicationUniversalIdentifier }: {
         filePath: string;
         builtHandlerPath: string;
         fileFolder: FileFolder;

package/dist/cli/utilities/build/common/esbuild-result-processor.d.ts

@@ -1,6 +1,6 @@
-import { OnFileBuiltCallback } from './restartable-watcher-interface';
-import { FileFolder } from 'twenty-shared/types';
 import type * as esbuild from 'esbuild';
+import { type OnFileBuiltCallback } from '../../../../cli/utilities/build/common/restartable-watcher-interface';
+import { type FileFolder } from 'twenty-shared/types';
 export type ProcessEsbuildResultParams = {
     result: esbuild.BuildResult;
     appPath: string;

package/dist/cli/utilities/build/common/esbuild-watcher.d.ts

@@ -1,6 +1,6 @@
-import { RestartableWatcher, RestartableWatcherOptions } from './restartable-watcher-interface';
-import { FileFolder } from 'twenty-shared/types';
+import { type RestartableWatcher, type RestartableWatcherOptions } from '../../../../cli/utilities/build/common/restartable-watcher-interface';
 import * as esbuild from 'esbuild';
+import { FileFolder } from 'twenty-shared/types';
 export declare const LOGIC_FUNCTION_EXTERNAL_MODULES: string[];
 export type EsbuildWatcherConfig = {
     externalModules: string[];

package/dist/cli/utilities/build/common/file-upload-watcher.d.ts

@@ -1,4 +1,4 @@
-import { FileFolder } from 'twenty-shared/types';
+import { type FileFolder } from 'twenty-shared/types';
 export type AssetWatcherOptions = {
     appPath: string;
     fileFolder: FileFolder;

package/dist/cli/utilities/build/common/front-component-build/jsx-runtime-remote-wrapper-plugin.d.ts

@@ -0,0 +1,6 @@
+import type * as esbuild from 'esbuild';
+type JsxRuntimeRemoteWrapperPluginOptions = {
+    usePreact?: boolean;
+};
+export declare const createJsxRuntimeRemoteWrapperPlugin: (options?: JsxRuntimeRemoteWrapperPluginOptions | undefined) => esbuild.Plugin;
+export {};

package/dist/cli/utilities/build/common/front-component-build/jsx-transform-to-remote-dom-worker-format-plugin.d.ts

@@ -1,3 +1,2 @@
 import type * as esbuild from 'esbuild';
-export { replaceHtmlTagsWithRemoteComponents as transformJsxToRemoteComponents } from './utils/replace-html-tags-with-remote-components';
 export declare const jsxTransformToRemoteDomWorkerFormatPlugin: esbuild.Plugin;

package/dist/cli/utilities/build/common/front-component-build/preact-alias-plugin.d.ts

@@ -0,0 +1,2 @@
+import type * as esbuild from 'esbuild';
+export declare const createPreactAliasPlugin: () => esbuild.Plugin;

package/dist/cli/utilities/build/common/front-component-build/utils/get-front-component-build-plugins.d.ts

@@ -1,2 +1,6 @@
 import type * as esbuild from 'esbuild';
-export declare const getFrontComponentBuildPlugins: () => esbuild.Plugin[];
+type GetFrontComponentBuildPluginsOptions = {
+    usePreact?: boolean;
+};
+export declare const getFrontComponentBuildPlugins: (options?: GetFrontComponentBuildPluginsOptions | undefined) => esbuild.Plugin[];
+export {};

package/dist/cli/utilities/build/common/restartable-watcher-interface.d.ts

@@ -1,5 +1,5 @@
-import { FileFolder } from 'twenty-shared/types';
-import { Location } from 'esbuild';
+import { type FileFolder } from 'twenty-shared/types';
+import { type Location } from 'esbuild';
 export interface RestartableWatcher {
     restart(sourcePaths: string[]): Promise<void>;
     start(): Promise<void>;

package/dist/cli/utilities/build/common/tsc-watcher.d.ts

@@ -0,0 +1,18 @@
+import { type TypecheckError } from '../../../../cli/utilities/build/common/typecheck-plugin';
+export type TscWatcherOptions = {
+    appPath: string;
+    onErrors: (errors: TypecheckError[]) => void;
+};
+export declare class TscWatcher {
+    private appPath;
+    private onErrors;
+    private process;
+    private pendingErrors;
+    private buffer;
+    private hasErrors;
+    constructor(options: TscWatcherOptions);
+    start(): Promise<void>;
+    close(): void;
+    private handleOutput;
+    private processLine;
+}

package/dist/cli/utilities/build/common/typecheck-plugin.d.ts

@@ -0,0 +1,10 @@
+import type * as esbuild from 'esbuild';
+export type TypecheckError = {
+    text: string;
+    file: string;
+    line: number;
+    column: number;
+};
+export declare const parseTscOutputLine: (line: string) => TypecheckError | null;
+export declare const runTypecheck: (appPath: string) => Promise<TypecheckError[]>;
+export declare const createTypecheckPlugin: (appPath: string) => esbuild.Plugin;

package/dist/cli/utilities/build/manifest/manifest-build.d.ts

@@ -1,5 +1,5 @@
-import { EntityFilePaths } from './manifest-extract-config';
-import { Manifest } from 'twenty-shared/application';
+import { type EntityFilePaths } from '../../../../cli/utilities/build/manifest/manifest-extract-config';
+import { type Manifest } from 'twenty-shared/application';
 export declare const buildManifest: (appPath: string) => Promise<{
     manifest: Manifest | null;
     filePaths: EntityFilePaths;

package/dist/cli/utilities/build/manifest/manifest-extract-config-from-file.d.ts

@@ -1,4 +1,4 @@
-import { ValidationResult } from '../../../../sdk';
+import { type ValidationResult } from '../../../../sdk';
 export declare const extractManifestFromFile: <T>({ filePath, appPath, }: {
     filePath: string;
     appPath: string;

package/dist/cli/utilities/build/manifest/manifest-extract-config.d.ts

@@ -4,7 +4,11 @@ export declare enum TargetFunction {
     DefineLogicFunction = "defineLogicFunction",
     DefineObject = "defineObject",
     DefineRole = "defineRole",
-    DefineFrontComponent = "defineFrontComponent"
+    DefineSkill = "defineSkill",
+    DefineFrontComponent = "defineFrontComponent",
+    DefineView = "defineView",
+    DefineNavigationMenuItem = "defineNavigationMenuItem",
+    DefinePageLayout = "definePageLayout"
 }
 export declare enum ManifestEntityKey {
     Application = "application",
@@ -12,8 +16,12 @@ export declare enum ManifestEntityKey {
     LogicFunctions = "logicFunctions",
     Objects = "objects",
     Roles = "roles",
+    Skills = "skills",
     FrontComponents = "frontComponents",
-    PublicAssets = "publicAssets"
+    PublicAssets = "publicAssets",
+    Views = "views",
+    NavigationMenuItems = "navigationMenuItems",
+    PageLayouts = "pageLayouts"
 }
 export type EntityFilePaths = Record<ManifestEntityKey, string[]>;
 export declare const TARGET_FUNCTION_TO_ENTITY_KEY_MAPPING: Record<TargetFunction, ManifestEntityKey>;

package/dist/cli/utilities/build/manifest/manifest-reader.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from 'twenty-shared/application';
+export declare const readManifestFromFile: (appPath: string) => Promise<Manifest | null>;

package/dist/cli/utilities/build/manifest/manifest-update-checksums.d.ts

@@ -1,6 +1,6 @@
-import { Manifest } from 'twenty-shared/application';
+import { type Manifest } from 'twenty-shared/application';
 import { FileFolder } from 'twenty-shared/types';
-import { EntityFilePaths } from './manifest-extract-config';
+import type { EntityFilePaths } from '../../../../cli/utilities/build/manifest/manifest-extract-config';
 export type ManifestBuildResult = {
     manifest: Manifest | null;
     filePaths: EntityFilePaths;

package/dist/cli/utilities/build/manifest/manifest-validate.d.ts

@@ -1,4 +1,4 @@
-import { Manifest } from 'twenty-shared/application';
+import { type Manifest } from 'twenty-shared/application';
 export declare const manifestValidate: (manifest: Manifest) => {
     errors: string[];
     warnings: string[];

package/dist/cli/utilities/build/manifest/manifest-writer.d.ts

@@ -1,2 +1,2 @@
-import { Manifest } from 'twenty-shared/application';
+import { type Manifest } from 'twenty-shared/application';
 export declare const writeManifestToOutput: (appPath: string, manifest: Manifest) => Promise<string>;

package/dist/cli/utilities/build/manifest/utils/generate-default-field-universal-identifier.d.ts

@@ -0,0 +1,5 @@
+import type { ObjectConfig } from '../../../../../sdk/objects/object-config';
+export declare const generateDefaultFieldUniversalIdentifier: ({ objectConfig, fieldName, }: {
+    objectConfig: ObjectConfig;
+    fieldName: string;
+}) => string;

package/dist/cli/utilities/build/manifest/utils/get-default-fields-in-object-fields.d.ts

@@ -0,0 +1,6 @@
+import type { ObjectConfig } from '../../../../../sdk/objects/object-config';
+import { type FieldManifest, type ObjectFieldManifest } from 'twenty-shared/application';
+export declare const getDefaultFieldsInObjectFields: (objectConfig: ObjectConfig) => {
+    objectFields: ObjectFieldManifest[];
+    fields: FieldManifest[];
+};

package/dist/cli/utilities/build/manifest/utils/get-default-object-fields.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectConfig } from '../../../../../sdk/objects/object-config';
+import { type ObjectFieldManifest } from 'twenty-shared/application';
+export declare const getDefaultObjectFields: (objectConfig: ObjectConfig) => ObjectFieldManifest[];

package/dist/cli/utilities/build/manifest/utils/get-default-relation-object-fields.d.ts

@@ -0,0 +1,6 @@
+import type { ObjectConfig } from '../../../../../sdk/objects/object-config';
+import { type FieldManifest, type ObjectFieldManifest } from 'twenty-shared/application';
+export declare const getDefaultRelationObjectFields: (objectConfig: ObjectConfig) => {
+    objectFields: ObjectFieldManifest[];
+    fields: FieldManifest[];
+};

package/dist/cli/utilities/client/client-service.d.ts

@@ -1,8 +1,10 @@
-export declare const GENERATED_FOLDER_NAME = "generated";
 export declare class ClientService {
-    private configService;
     private apiService;
     constructor();
-    generate(appPath: string): Promise<void>;
+    generate({ appPath, authToken }: {
+        appPath: string;
+        authToken?: string;
+    }): Promise<void>;
+    private resolveGeneratedPath;
     private injectTwentyClient;
 }

package/dist/cli/utilities/config/config-service.d.ts

@@ -1,6 +1,8 @@
 export type TwentyConfig = {
     apiUrl: string;
     apiKey?: string;
+    applicationAccessToken?: string;
+    applicationRefreshToken?: string;
 };
 export declare class ConfigService {
     private readonly configPath;

package/dist/cli/utilities/dev/orchestrator/dev-mode-orchestrator-state.d.ts

@@ -0,0 +1,75 @@
+import { type EntityFilePaths } from '../../../../cli/utilities/build/manifest/manifest-extract-config';
+import { type BuildManifestOrchestratorStepOutput } from '../../../../cli/utilities/dev/orchestrator/steps/build-manifest-orchestrator-step';
+import { type CheckServerOrchestratorStepOutput } from '../../../../cli/utilities/dev/orchestrator/steps/check-server-orchestrator-step';
+import { type ResolveApplicationOrchestratorStepOutput } from '../../../../cli/utilities/dev/orchestrator/steps/resolve-application-orchestrator-step';
+import { type StartWatchersOrchestratorStepOutput } from '../../../../cli/utilities/dev/orchestrator/steps/start-watchers-orchestrator-step';
+import { type SyncApplicationOrchestratorStepOutput } from '../../../../cli/utilities/dev/orchestrator/steps/sync-application-orchestrator-step';
+import { type UploadFilesOrchestratorStepOutput } from '../../../../cli/utilities/dev/orchestrator/steps/upload-files-orchestrator-step';
+import { type Manifest, SyncableEntity } from 'twenty-shared/application';
+import { type FileFolder } from 'twenty-shared/types';
+export type OrchestratorStateStepEvent = {
+    message: string;
+    status: 'info' | 'success' | 'error' | 'warning';
+};
+export type OrchestratorStateEvent = OrchestratorStateStepEvent & {
+    id: number;
+    timestamp: Date;
+};
+export type OrchestratorStateSyncStatus = 'idle' | 'building' | 'syncing' | 'synced' | 'error';
+export type OrchestratorStateStepStatus = 'idle' | 'in_progress' | 'done' | 'error';
+export type OrchestratorStepState<TOutput> = {
+    output: TOutput;
+    status: OrchestratorStateStepStatus;
+};
+export type OrchestratorStateFileStatus = 'pending' | 'building' | 'uploading' | 'success' | 'error';
+export type OrchestratorStateEntityInfo = {
+    name: string;
+    path: string;
+    type?: SyncableEntity;
+    status: OrchestratorStateFileStatus;
+};
+export type OrchestratorStateBuiltFileInfo = {
+    checksum: string;
+    builtPath: string;
+    sourcePath: string;
+    fileFolder: FileFolder;
+};
+export type OrchestratorStatePipeline = {
+    status: OrchestratorStateSyncStatus;
+    isSyncing: boolean;
+    error: string | null;
+    appName: string | null;
+};
+export declare class OrchestratorState {
+    appPath: string;
+    frontendUrl?: string;
+    steps: {
+        checkServer: OrchestratorStepState<CheckServerOrchestratorStepOutput>;
+        ensureValidTokens: OrchestratorStepState<Record<string, never>>;
+        resolveApplication: OrchestratorStepState<ResolveApplicationOrchestratorStepOutput>;
+        buildManifest: OrchestratorStepState<BuildManifestOrchestratorStepOutput>;
+        uploadFiles: OrchestratorStepState<UploadFilesOrchestratorStepOutput>;
+        generateApiClient: OrchestratorStepState<Record<string, never>>;
+        syncApplication: OrchestratorStepState<SyncApplicationOrchestratorStepOutput>;
+        startWatchers: OrchestratorStepState<StartWatchersOrchestratorStepOutput>;
+    };
+    previousObjectsFieldsFingerprint: string | null;
+    pipeline: OrchestratorStatePipeline;
+    entities: Map<string, OrchestratorStateEntityInfo>;
+    events: OrchestratorStateEvent[];
+    private eventIdCounter;
+    onChange?: () => void;
+    constructor(options: {
+        appPath: string;
+        frontendUrl?: string;
+    });
+    notify(): void;
+    updatePipeline(update: Partial<OrchestratorStatePipeline>): void;
+    applyStepEvents(stepEvents: OrchestratorStateStepEvent[]): void;
+    addEvent(event: OrchestratorStateStepEvent): void;
+    updateEntityStatus(filePath: string, status: OrchestratorStateFileStatus): void;
+    removeEntity(filePath: string): void;
+    updateAllEntitiesStatus(status: OrchestratorStateFileStatus): void;
+    updateEntitiesFromManifest(manifestFilePaths: EntityFilePaths): void;
+    hasObjectsOrFieldsChanged(manifest: Manifest): boolean;
+}

package/dist/cli/utilities/dev/orchestrator/dev-mode-orchestrator.d.ts

@@ -0,0 +1,29 @@
+import { type OrchestratorState } from '../../../../cli/utilities/dev/orchestrator/dev-mode-orchestrator-state';
+export type DevModeOrchestratorOptions = {
+    state: OrchestratorState;
+    debounceMs?: number;
+};
+export declare class DevModeOrchestrator {
+    private state;
+    private debounceMs;
+    private syncTimer;
+    private serverCheckInterval;
+    private checkServerStep;
+    private ensureValidTokensStep;
+    private buildManifestStep;
+    private resolveApplicationStep;
+    private uploadFilesStep;
+    private generateApiClientStep;
+    private syncApplicationStep;
+    private startWatchersStep;
+    constructor(options: DevModeOrchestratorOptions);
+    start(): Promise<void>;
+    close(): Promise<void>;
+    getState(): OrchestratorState;
+    private handleFileBuilt;
+    private checkServerHealth;
+    private scheduleSync;
+    private performSync;
+    private runSyncPipeline;
+    private initializePipeline;
+}

package/dist/cli/utilities/dev/orchestrator/steps/build-manifest-orchestrator-step.d.ts

@@ -0,0 +1,16 @@
+import { type ManifestBuildResult } from '../../../../../cli/utilities/build/manifest/manifest-update-checksums';
+import { type OrchestratorState } from '../../../../../cli/utilities/dev/orchestrator/dev-mode-orchestrator-state';
+export type BuildManifestOrchestratorStepOutput = {
+    result: ManifestBuildResult | null;
+};
+export declare class BuildManifestOrchestratorStep {
+    private state;
+    private notify;
+    constructor({ state, notify }: {
+        state: OrchestratorState;
+        notify: () => void;
+    });
+    execute(input: {
+        appPath: string;
+    }): Promise<ManifestBuildResult | null>;
+}

package/dist/cli/utilities/dev/orchestrator/steps/check-server-orchestrator-step.d.ts

@@ -0,0 +1,17 @@
+import { type ApiService } from '../../../../../cli/utilities/api/api-service';
+import { type OrchestratorState } from '../../../../../cli/utilities/dev/orchestrator/dev-mode-orchestrator-state';
+export type CheckServerOrchestratorStepOutput = {
+    isReady: boolean;
+    errorLogged: boolean;
+};
+export declare class CheckServerOrchestratorStep {
+    private apiService;
+    private state;
+    private notify;
+    constructor({ apiService, state, notify }: {
+        apiService: ApiService;
+        state: OrchestratorState;
+        notify: () => void;
+    });
+    execute(): Promise<boolean>;
+}

package/dist/cli/utilities/dev/orchestrator/steps/ensure-valid-tokens-orchestrator-step.d.ts

@@ -0,0 +1,22 @@
+import { type ApiService } from '../../../../../cli/utilities/api/api-service';
+import { type ConfigService } from '../../../../../cli/utilities/config/config-service';
+import { type OrchestratorState } from '../../../../../cli/utilities/dev/orchestrator/dev-mode-orchestrator-state';
+export declare class EnsureValidTokensOrchestratorStep {
+    private apiService;
+    private configService;
+    private state;
+    private notify;
+    constructor({ apiService, configService, state, notify }: {
+        apiService: ApiService;
+        configService: ConfigService;
+        state: OrchestratorState;
+        notify: () => void;
+    });
+    execute(input: {
+        applicationId: string | null;
+    }): Promise<void>;
+    exchangeTokens(input: {
+        applicationId: string;
+    }): Promise<void>;
+    private isTokenExpired;
+}

package/dist/cli/utilities/dev/orchestrator/steps/generate-api-client-orchestrator-step.d.ts

@@ -0,0 +1,18 @@
+import { type ClientService } from '../../../../../cli/utilities/client/client-service';
+import { type ConfigService } from '../../../../../cli/utilities/config/config-service';
+import { type OrchestratorState } from '../../../../../cli/utilities/dev/orchestrator/dev-mode-orchestrator-state';
+export declare class GenerateApiClientOrchestratorStep {
+    private clientService;
+    private configService;
+    private state;
+    private notify;
+    constructor({ clientService, configService, state, notify }: {
+        clientService: ClientService;
+        configService: ConfigService;
+        state: OrchestratorState;
+        notify: () => void;
+    });
+    execute(input: {
+        appPath: string;
+    }): Promise<void>;
+}

package/dist/cli/utilities/dev/orchestrator/steps/resolve-application-orchestrator-step.d.ts

@@ -0,0 +1,20 @@
+import { type ApiService } from '../../../../../cli/utilities/api/api-service';
+import { type OrchestratorState } from '../../../../../cli/utilities/dev/orchestrator/dev-mode-orchestrator-state';
+import { type Manifest } from 'twenty-shared/application';
+export type ResolveApplicationOrchestratorStepOutput = {
+    applicationId: string | null;
+    universalIdentifier: string | null;
+};
+export declare class ResolveApplicationOrchestratorStep {
+    private apiService;
+    private state;
+    private notify;
+    constructor({ apiService, state, notify }: {
+        apiService: ApiService;
+        state: OrchestratorState;
+        notify: () => void;
+    });
+    execute(input: {
+        manifest: Manifest;
+    }): Promise<ResolveApplicationOrchestratorStepOutput>;
+}

package/dist/cli/utilities/dev/orchestrator/steps/start-watchers-orchestrator-step.d.ts

@@ -0,0 +1,43 @@
+import { type ManifestBuildResult } from '../../../../../cli/utilities/build/manifest/manifest-update-checksums';
+import { type OrchestratorState } from '../../../../../cli/utilities/dev/orchestrator/dev-mode-orchestrator-state';
+import { FileFolder } from 'twenty-shared/types';
+export type FileBuiltEvent = {
+    fileFolder: FileFolder;
+    builtPath: string;
+    sourcePath: string;
+    checksum: string;
+};
+export type StartWatchersOrchestratorStepOutput = {
+    watchersStarted: boolean;
+};
+export declare class StartWatchersOrchestratorStep {
+    private state;
+    private scheduleSync;
+    private notify;
+    private onFileBuilt;
+    private manifestWatcher;
+    private logicFunctionsWatcher;
+    private frontComponentsWatcher;
+    private assetWatcher;
+    private dependencyWatcher;
+    private tscWatcher;
+    constructor(options: {
+        state: OrchestratorState;
+        scheduleSync: () => void;
+        notify: () => void;
+        onFileBuilt: (event: FileBuiltEvent) => void;
+    });
+    start(): Promise<void>;
+    handleWatcherRestarts(result: ManifestBuildResult): Promise<void>;
+    close(): Promise<void>;
+    private handleChangeDetected;
+    private handleFileBuildError;
+    private handleFileBuilt;
+    private startFileWatchers;
+    private startLogicFunctionsWatcher;
+    private startFrontComponentsWatcher;
+    private startAssetWatcher;
+    private startDependencyWatcher;
+    private startTscWatcher;
+    private handleTypecheckErrors;
+}