@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

package/dist/types/types/config/index.d.ts

@@ -0,0 +1,48 @@
+import type { CLIPlugin, CLIPluginExtends } from '@modern-js/plugin';
+import type { BffUserConfig, ServerUserConfig } from '@modern-js/server-core';
+import type { RsbuildConfig } from '@rsbuild/core';
+import type { AppToolsExtendAPI, AppToolsExtendContext, AppToolsExtendHooks } from '../plugin';
+import type { DeployUserConfig } from './deploy';
+import type { DevUserConfig } from './dev';
+import type { ExperimentsUserConfig } from './experiments';
+import type { HtmlUserConfig } from './html';
+import type { OutputUserConfig } from './output';
+import type { PerformanceUserConfig } from './performance';
+import type { ResolveUserConfig } from './resolve';
+import type { SecurityUserConfig } from './security';
+import type { SourceUserConfig } from './source';
+import type { TestingUserConfig } from './testing';
+import type { ToolsUserConfig } from './tools';
+export * from './output';
+export type AppToolsBuilderPlugins = NonNullable<RsbuildConfig['plugins']>;
+export interface AppToolsUserConfig {
+    resolve?: ResolveUserConfig;
+    server?: ServerUserConfig;
+    source?: SourceUserConfig;
+    output?: OutputUserConfig;
+    experiments?: ExperimentsUserConfig;
+    /**
+     * The configuration of `bff` is provided by `bff` plugin.
+     * Please use `yarn new` or `pnpm new` to enable the corresponding capability.
+     * @requires `bff` plugin
+     */
+    bff?: BffUserConfig;
+    dev?: DevUserConfig;
+    deploy?: DeployUserConfig;
+    html?: HtmlUserConfig;
+    tools?: ToolsUserConfig;
+    security?: SecurityUserConfig;
+    testing?: TestingUserConfig;
+    builderPlugins?: AppToolsBuilderPlugins;
+    performance?: PerformanceUserConfig;
+    environments?: RsbuildConfig['environments'];
+    splitChunks?: RsbuildConfig['splitChunks'];
+    plugins?: CliPlugin<AppTools>[];
+}
+interface SharedNormalizedConfig<RawConfig> {
+    cliOptions?: Record<string, any>;
+    _raw: RawConfig;
+}
+export type AppToolsNormalizedConfig<Config = AppToolsUserConfig> = Required<Config> & SharedNormalizedConfig<Config>;
+export type AppTools = Required<CLIPluginExtends<AppToolsUserConfig, AppToolsNormalizedConfig, AppToolsExtendContext, AppToolsExtendAPI, AppToolsExtendHooks>>;
+export type CliPlugin<Extends extends CLIPluginExtends> = CLIPlugin<Extends>;

package/dist/types/types/config/output.d.ts

@@ -0,0 +1,61 @@
+import type { BuilderConfig } from '@modern-js/builder';
+import type { SSGConfig, SSGMultiEntryOptions } from '@modern-js/types';
+import type CompressionPlugin from 'compression-webpack-plugin';
+import type { UnwrapBuilderConfig } from '../utils';
+type CompressionPluginOptions = NonNullable<ConstructorParameters<typeof CompressionPlugin>[0]>;
+export type PrecompressCodecOptions = boolean | CompressionPluginOptions;
+export interface PrecompressConfig {
+    /**
+     * Configure gzip precompression options.
+     * `true` means using default options.
+     * `false` means disabling gzip precompression.
+     * @default true
+     */
+    gzip?: PrecompressCodecOptions;
+    /**
+     * Configure brotli precompression options.
+     * `true` means using default options.
+     * `false` means disabling brotli precompression.
+     * @default true
+     */
+    brotli?: PrecompressCodecOptions;
+}
+export interface OutputUserConfig extends UnwrapBuilderConfig<BuilderConfig, 'output'> {
+    /**
+     * Enable SSG for self-controlled routing or conventional routing.
+     * @default false
+     */
+    ssg?: SSGConfig;
+    /**
+     * Specify SSG configuration by entries for multi-entry apps.
+     * Takes precedence over `ssg` when provided.
+     */
+    ssgByEntries?: SSGMultiEntryOptions;
+    /**
+     * When using convention-based routing, the framework will split js and css based on the route to load on demand.
+     * If your project does not want to split js and css based on routes, you can set this option to false.
+     * @default true
+     */
+    splitRouteChunks?: boolean;
+    /**
+     * Used to control whether to inject convention-based routing information into the HTML.
+     * @default true
+     */
+    enableInlineRouteManifests?: boolean;
+    /**
+     * Used to control whether to inject convention-based routing information into the HTML.
+     * @default false
+     */
+    disableInlineRouteManifests?: boolean;
+    /**
+     * Specify the temporary directory for framework generated files.
+     */
+    tempDir?: string;
+    /**
+     * Generate precompressed static assets by using compression-webpack-plugin.
+     * `true` means enabling both gzip and brotli with default options.
+     * @default true
+     */
+    precompress?: boolean | PrecompressConfig;
+}
+export type { SSGConfig, SSGMultiEntryOptions, SSGRouteOptions, SSGSingleEntryOptions, } from '@modern-js/types';

package/dist/types/types/config/performance.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderConfig } from '@modern-js/builder';
+import type { UnwrapBuilderConfig } from '../utils';
+export type PerformanceUserConfig = UnwrapBuilderConfig<BuilderConfig, 'performance'>;

package/dist/types/types/config/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderConfig } from '@modern-js/builder';
+export type ResolveUserConfig = BuilderConfig['resolve'];

package/dist/types/types/config/security.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderConfig } from '@modern-js/builder';
+export type SecurityUserConfig = Required<BuilderConfig>['security'];

package/dist/types/types/config/source.d.ts

@@ -0,0 +1,61 @@
+import type { BuilderConfig } from '@modern-js/builder';
+export type Entry = string | {
+    /**
+     * The entry file path.
+     */
+    entry: string;
+    /**
+     * Disable framework's behavior of automatically generating entry code.
+     */
+    disableMount?: boolean;
+    /**
+     * use src/{entryName}/entry.tsx to custom entry
+     */
+    customEntry?: boolean;
+};
+export type Entries = Record<string, Entry>;
+export interface SourceUserConfig extends NonNullable<BuilderConfig['source']> {
+    /**
+     * Add code before each page entry. It will be executed before the page code.
+     * @default []
+     */
+    preEntry?: string | string[];
+    /**
+     * Used to configure custom page entries.
+     */
+    entries?: Entries;
+    /**
+     * Used to configure the main entry name.
+     * @default 'main'
+     */
+    mainEntryName?: string;
+    /**
+     * This option is used for Module Federation scenario.
+     * When this option is enabled, framework will wrap the automatically generated entry files with dynamic import.
+     * @default false
+     */
+    enableAsyncEntry?: boolean;
+    /**
+     * When enabled, framework will inject `source.preEntry` into the top of the
+     * auto-generated entry file (`index.jsx`) and will not pass `source.preEntry`
+     * to builder config.
+     * This is useful when `source.enableAsyncEntry` is enabled and you still want
+     * preEntry to run before the real entry code.
+     * @default false
+     */
+    enableAsyncPreEntry?: boolean;
+    /**
+     * Used to disable the functionality of automatically identifying page entry points based on directory structure.
+     * @default false
+     */
+    disableDefaultEntries?: boolean;
+    /**
+     * By default, framework scans the src directory to identify page entries.
+     * You can customize the directory used for identifying page entries with this option.
+     */
+    entriesDir?: string;
+    /**
+     * Customize the directory of the framework configuration files.
+     */
+    configDir?: string;
+}

package/dist/types/types/config/testing.d.ts

@@ -0,0 +1,8 @@
+import type { TestConfig } from '@modern-js/types';
+export interface TestingUserConfig {
+    /**
+     * Decide which transformer will be used to compile file
+     * @default 'babel-jest'
+     */
+    transformer?: TestConfig['transformer'];
+}

package/dist/types/types/config/tools.d.ts

@@ -0,0 +1,21 @@
+import type { BuilderConfig } from '@modern-js/builder';
+import type { JestConfig } from '@modern-js/types';
+import type { UnwrapBuilderConfig } from '../utils';
+type BuilderToolsConfig = UnwrapBuilderConfig<BuilderConfig, 'tools'>;
+export interface ToolsUserConfig extends Omit<BuilderToolsConfig, 'swc'> {
+    /**
+     * Used to custom Jest configurations.
+     * @requires `test` plugin.
+     * The configuration of `tools.jest` is provided by `test` plugin.
+     * Please use `yarn new` or `pnpm new` to enable the corresponding capability.
+     */
+    jest?: JestConfig | ((jestConfig: JestConfig) => JestConfig);
+    /**
+     * Used to custom SWC configurations.
+     * @requires `swc` plugin.
+     * The configuration of `swc` is provided by `swc` plugin.
+     * Please use `yarn new` or `pnpm new` to enable the corresponding capability.
+     */
+    swc?: BuilderToolsConfig['swc'];
+}
+export {};

package/dist/types/types/index.d.ts

@@ -0,0 +1,10 @@
+import type { CLIPluginAPI, CLIPluginExtends, RuntimePluginConfig, ServerPluginConfig } from '@modern-js/plugin';
+import type { AppTools, AppToolsNormalizedConfig, AppToolsUserConfig } from './config';
+export type { Rspack } from '@modern-js/builder';
+export type { BffNormalizedConfig, BffUserConfig, LoaderContext, OnError, OnTiming, Params, RequestHandler, RequestHandlerConfig, RequestHandlerOptions, Resource, ServerNormalizedConfig, ServerUserConfig, SSR, SSRByEntries, } from '@modern-js/server-core';
+export * from './config';
+export type { CLIPluginExtends, RuntimePluginConfig, ServerPluginConfig };
+export type AppUserConfig = AppToolsUserConfig;
+export type AppNormalizedConfig = AppToolsNormalizedConfig;
+export type AppToolsAPI = CLIPluginAPI<AppTools>;
+export type { AppToolsContext, AppToolsExtendAPI, AppToolsExtendContext, AppToolsExtendHooks, AppToolsHooks as AppToolsFeatureHooks, } from './plugin';

package/dist/types/types/plugin.d.ts

@@ -0,0 +1,114 @@
+import type { AppContext, AsyncHook, InternalContext, PluginHook, PluginHookTap, TransformFunction } from '@modern-js/plugin';
+import type { Hooks } from '@modern-js/plugin/cli';
+import type { Entrypoint, HtmlPartials, HtmlTemplates, NestedRouteForCli, PageRoute, RouteLegacy, ServerPlugin, ServerRoute } from '@modern-js/types';
+import type { getHookRunners } from '../compat/hooks';
+import type { AppTools } from '.';
+import type { AppToolsNormalizedConfig, AppToolsUserConfig } from './config';
+export type AfterPrepareFn = () => Promise<void> | void;
+export type CheckEntryPointFn = TransformFunction<{
+    path: string;
+    entry: false | string;
+}>;
+export type ModifyEntrypointsFn = TransformFunction<{
+    entrypoints: Entrypoint[];
+}>;
+export type ModifyFileSystemRoutesFn = TransformFunction<{
+    entrypoint: Entrypoint;
+    routes: RouteLegacy[] | (NestedRouteForCli | PageRoute)[];
+}>;
+export type DeplpoyFn = () => Promise<void> | void;
+export type GenerateEntryCodeFn = (params: {
+    entrypoints: Entrypoint[];
+}) => Promise<void> | void;
+export type BeforeGenerateRoutesFn = TransformFunction<{
+    entrypoint: Entrypoint;
+    code: string;
+}>;
+export type BeforePrintInstructionsFn = TransformFunction<{
+    instructions: string;
+}>;
+export type AddRuntimeExportsFn = () => Promise<void> | void;
+export interface AppToolsExtendAPI {
+    onAfterPrepare: PluginHookTap<AfterPrepareFn>;
+    deploy: PluginHookTap<DeplpoyFn>;
+    checkEntryPoint: PluginHookTap<CheckEntryPointFn>;
+    modifyEntrypoints: PluginHookTap<ModifyEntrypointsFn>;
+    modifyFileSystemRoutes: PluginHookTap<ModifyFileSystemRoutesFn>;
+    generateEntryCode: PluginHookTap<GenerateEntryCodeFn>;
+    onBeforeGenerateRoutes: PluginHookTap<BeforeGenerateRoutesFn>;
+    /**
+     * @deprecated
+     */
+    onBeforePrintInstructions: PluginHookTap<BeforePrintInstructionsFn>;
+    /**
+     * @deprecated use getAppContext instead
+     */
+    useAppContext: () => AppToolsContext;
+    /**
+     * @deprecated use getConfig instead
+     */
+    useConfigContext: () => AppToolsUserConfig;
+    /**
+     * @deprecated use getNormalizedConfig instead
+     */
+    useResolvedConfigContext: () => AppToolsNormalizedConfig<AppToolsUserConfig>;
+    /**
+     * @deprecated use api.xx instead
+     */
+    useHookRunners: () => ReturnType<typeof getHookRunners>;
+}
+export interface AppToolsExtendHooks extends Record<string, PluginHook<(...args: any[]) => any>> {
+    onAfterPrepare: AsyncHook<AfterPrepareFn>;
+    deploy: AsyncHook<DeplpoyFn>;
+    checkEntryPoint: AsyncHook<CheckEntryPointFn>;
+    modifyEntrypoints: AsyncHook<ModifyEntrypointsFn>;
+    modifyFileSystemRoutes: AsyncHook<ModifyFileSystemRoutesFn>;
+    generateEntryCode: AsyncHook<GenerateEntryCodeFn>;
+    onBeforeGenerateRoutes: AsyncHook<BeforeGenerateRoutesFn>;
+    /**
+     * @deprecated
+     */
+    onBeforePrintInstructions: AsyncHook<BeforePrintInstructionsFn>;
+}
+export interface AppToolsExtendContext {
+    metaName: string;
+    internalDirectory: string;
+    sharedDirectory: string;
+    internalDirAlias: string;
+    internalSrcAlias: string;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    runtimeConfigFile: string;
+    serverPlugins: ServerPlugin[];
+    moduleType: 'module' | 'commonjs';
+    /** Information for entry points */
+    entrypoints: Entrypoint[];
+    /** Selected entry points */
+    checkedEntries: string[];
+    /** Information for server routes */
+    serverRoutes: ServerRoute[];
+    /** Whether to use api only mode */
+    apiOnly: boolean;
+    _internalContext: InternalContext<AppTools>;
+    /**
+     * Information for HTML templates by entry
+     * @private
+     */
+    partialsByEntrypoint?: Record<string, HtmlPartials>;
+    /**
+     * Information for HTML templates
+     * @private
+     */
+    htmlTemplates: HtmlTemplates;
+    /**
+     * @deprecated compat old plugin, default is app tools
+     */
+    toolsType?: string;
+    /**
+     * Identification for bff runtime framework
+     * @private
+     */
+    bffRuntimeFramework?: 'hono' | 'effect';
+}
+export type AppToolsContext = AppContext<AppTools> & AppToolsExtendContext;
+export type AppToolsHooks = Hooks<AppToolsUserConfig, AppToolsNormalizedConfig, {}, {}> & AppToolsExtendHooks;

package/dist/types/types/utils.d.ts

@@ -0,0 +1 @@
+export type UnwrapBuilderConfig<Config, Key extends keyof Config> = Required<Config>[Key];

package/dist/types/ultramodern/designSystem.d.ts

@@ -0,0 +1,54 @@
+export declare const DESIGN_SYSTEM_MODES: readonly ["off", "tokens", "components", "strict"];
+export declare const DESIGN_SYSTEM_OVERRIDE_LAYERS: readonly ["brand", "vertical", "application"];
+export type DesignSystemMode = (typeof DESIGN_SYSTEM_MODES)[number];
+export type DesignSystemOverrideLayer = (typeof DESIGN_SYSTEM_OVERRIDE_LAYERS)[number];
+export type DesignSystemTokenValue = string | number;
+export interface DesignSystemTokenPack {
+    id: string;
+    version: string;
+    brand: string;
+    tokens: Record<string, DesignSystemTokenValue>;
+}
+export interface DesignSystemOverride {
+    layer: DesignSystemOverrideLayer;
+    tokens?: Record<string, DesignSystemTokenValue>;
+    reason?: string;
+}
+export interface DesignSystemConsumerContract {
+    id: string;
+    requiredTokens?: string[];
+    unsupportedModes?: DesignSystemMode[];
+    tokenPackVersions?: Record<string, string>;
+}
+export interface DesignSystemRollbackMetadata {
+    tokenPack: string;
+    version: string;
+    reason: string;
+}
+export interface DesignSystemPinMetadata {
+    tokenPack: string;
+    version: string;
+    rollback: DesignSystemRollbackMetadata;
+}
+export interface DesignSystemVerticalContract {
+    mode: DesignSystemMode;
+    tokenPack?: string;
+    overrides?: DesignSystemOverride[];
+    pin?: DesignSystemPinMetadata;
+    consumers?: DesignSystemConsumerContract[];
+}
+export interface DesignSystemContract {
+    tokenPacks: DesignSystemTokenPack[];
+    verticals: Record<string, DesignSystemVerticalContract>;
+}
+export interface DesignSystemValidationIssue {
+    path: string;
+    message: string;
+}
+export interface DesignSystemValidationResult {
+    valid: boolean;
+    issues: DesignSystemValidationIssue[];
+}
+export declare const createDesignSystemTokenPackMap: (tokenPacks: DesignSystemTokenPack[]) => Map<string, DesignSystemTokenPack>;
+export declare const validateDesignSystemConsumerCompatibility: (vertical: DesignSystemVerticalContract, tokenPack: DesignSystemTokenPack | undefined, path?: string) => DesignSystemValidationResult;
+export declare const validateDesignSystemContract: (contract: DesignSystemContract) => DesignSystemValidationResult;

package/dist/types/utils/config.d.ts

@@ -0,0 +1,2 @@
+import type { AppNormalizedConfig } from '../types';
+export declare const emitResolvedConfig: (appDirectory: string, resolvedConfig: AppNormalizedConfig) => Promise<void>;

package/dist/types/utils/createServer.d.ts

@@ -0,0 +1,5 @@
+import type { Server } from 'node:http';
+import type { Http2SecureServer } from 'node:http2';
+export declare const getServer: () => Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> | Http2SecureServer<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse, typeof import("node:http2").Http2ServerRequest, typeof import("node:http2").Http2ServerResponse> | null;
+export declare const setServer: (newServer: Server | Http2SecureServer) => void;
+export declare const closeServer: () => Promise<void>;

package/dist/types/utils/env.d.ts

@@ -0,0 +1,2 @@
+import type { AppToolsContext } from '../types/plugin';
+export declare function getAutoInjectEnv(appContext: AppToolsContext): Record<string, string>;

package/dist/types/utils/generateWatchFiles.d.ts

@@ -0,0 +1,2 @@
+import type { AppToolsContext } from '../types/plugin';
+export declare function generateWatchFiles(appContext: AppToolsContext, configDir?: string): Promise<string[]>;

package/dist/types/utils/getConfigFile.d.ts

@@ -0,0 +1 @@
+export declare const getConfigFile: (configFile?: string, cwd?: string) => string | false;

package/dist/types/utils/getSelectedEntries.d.ts

@@ -0,0 +1,5 @@
+import type { Entrypoint } from '@modern-js/types';
+/**
+ * Allow user to select entrypoints to build.
+ */
+export declare const getSelectedEntries: (entry: string[] | boolean, entrypoints: Entrypoint[]) => Promise<string[]>;

package/dist/types/utils/initAppContext.d.ts

@@ -0,0 +1,31 @@
+export declare const initAppContext: ({ metaName, appDirectory, runtimeConfigFile, options, tempDir, }: {
+    metaName: string;
+    appDirectory: string;
+    runtimeConfigFile: string;
+    options?: {
+        srcDir?: string;
+        apiDir?: string;
+        distDir?: string;
+        sharedDir?: string;
+        bffRuntimeFramework?: "hono" | "effect";
+    };
+    tempDir?: string;
+}) => {
+    runtimeConfigFile: string;
+    ip: any;
+    port: number;
+    moduleType: any;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    sharedDirectory: string;
+    serverPlugins: never[];
+    internalDirectory: string;
+    htmlTemplates: {};
+    serverRoutes: never[];
+    entrypoints: never[];
+    checkedEntries: never[];
+    apiOnly: boolean;
+    internalDirAlias: string;
+    internalSrcAlias: string;
+    bffRuntimeFramework: "hono" | "effect";
+};

package/dist/types/utils/loadPlugins.d.ts

@@ -0,0 +1,13 @@
+import type { CLIPluginAPI, Plugin } from '@modern-js/plugin';
+import type { ServerPlugin as ServerPluginInstance } from '@modern-js/server-core';
+import type { InternalPlugins, ServerPlugin } from '@modern-js/types';
+import type { AppTools } from '../types';
+export declare function getServerPlugins(api: CLIPluginAPI<AppTools>, metaName?: string): Promise<ServerPlugin[]>;
+export declare function loadServerPlugins(api: CLIPluginAPI<AppTools>, appDirectory: string, metaName: string): Promise<ServerPluginInstance[]>;
+/**
+ * Load internal plugins which in @modern-js scope and user's custom plugins.
+ * @param appDirectory - Application root directory.
+ * @param internalPlugins - Internal plugins.
+ * @returns Plugin Objects has been required.
+ */
+export declare const loadInternalPlugins: (appDirectory: string, internalPlugins?: InternalPlugins) => Promise<Plugin[]>;

package/dist/types/utils/printInstructions.d.ts

@@ -0,0 +1,3 @@
+import type { AppNormalizedConfig } from '../types';
+import type { AppToolsContext, AppToolsHooks } from '../types/plugin';
+export declare const printInstructions: (hooks: AppToolsHooks, appContext: AppToolsContext, config: AppNormalizedConfig) => Promise<void>;

package/dist/types/utils/register.d.ts

@@ -0,0 +1,19 @@
+import { type Alias } from '@modern-js/utils';
+import type { ConfigChain } from '@rsbuild/core';
+type TsRuntimeRegisterMode = 'ts-node' | 'node-loader' | 'unsupported';
+interface TsRuntimeSetupOptions {
+    moduleType?: string;
+    /**
+     * User-configured `server.tsconfigPath`. Forwarded into the shared
+     * resolveServerTsconfig helper. Resolved relative to appDir when not
+     * absolute. Falls back to `<appDir>/tsconfig.json` when unset.
+     */
+    tsconfigPath?: string;
+}
+export declare const resolveTsRuntimeRegisterMode: (hasTsNode: boolean) => TsRuntimeRegisterMode;
+/**
+ * Setup TypeScript runtime support.
+ * Register ts-node for compilation and tsconfig-paths for path alias resolution.
+ */
+export declare const setupTsRuntime: (appDir: string, distDir: string, alias?: ConfigChain<Alias>, options?: TsRuntimeSetupOptions) => Promise<void>;
+export {};

package/dist/types/utils/restart.d.ts

@@ -0,0 +1,2 @@
+import type { AppToolsHooks } from '../types/plugin';
+export declare function restart(hooks: AppToolsHooks, filename: string): Promise<void>;

package/dist/types/utils/routes.d.ts

@@ -0,0 +1,4 @@
+import type { AppToolsContext } from '../types/plugin';
+export declare const generateRoutes: (appContext: AppToolsContext) => Promise<void>;
+export declare const getPathWithoutExt: (filename: string) => string;
+export declare const isMainEntry: (entryName: string, mainEntryName?: string) => boolean;

package/dist/types/utils/types.d.ts

@@ -0,0 +1,49 @@
+export type DevOptions = {
+    entry?: string[] | boolean;
+    config?: string;
+    apiOnly?: boolean;
+    analyze?: boolean;
+};
+export type BuildOptions = {
+    config?: string;
+    analyze?: boolean;
+    watch?: boolean;
+};
+export type DeployOptions = {
+    config?: string;
+    skipBuild?: boolean;
+};
+export type StartOptions = {
+    apiOnly?: boolean;
+};
+export type InspectOptions = {
+    env: string;
+    output: string;
+    verbose?: boolean;
+};
+export type InfoOptions = {
+    config?: string;
+    json?: boolean;
+};
+export type RuntimeStatusOptions = {
+    endpoint?: string;
+    token?: string;
+    tokenEnv?: string;
+    headerName?: string;
+    timeout?: string;
+    json?: boolean;
+};
+export type RuntimeFallbackSignalOptions = {
+    endpoint?: string;
+    app: string;
+    reason?: string;
+    phase?: string;
+    entry?: string;
+    runtimeDigest?: string;
+    metadata?: string;
+    token?: string;
+    tokenEnv?: string;
+    headerName?: string;
+    timeout?: string;
+    json?: boolean;
+};