Class Project

new Project(
    __namedParameters?: {
        committer?: ICommitter;
        compiler?: Compiler;
        compilerOptions?: tsc.CompilerOptions;
        config?: Partial<
            {
                accessControls?: {
                    canEditInStudio?: boolean;
                    hideOnUI?: boolean;
                    private?: boolean;
                    restrictTableAccess?: boolean;
                    runtimeAccessTracking?: string;
                    scopedAdministration?: boolean;
                    trackable?: boolean;
                    uninstallBlocked?: boolean;
                    userRole?: string;
                };
                active?: boolean;
                applicationRuntimePolicy?: "none"
                | "tracking"
                | "enforcing";
                appOutputDir?: string;
                clientDir?: string;
                compileOutputDir?: string;
                defaultLanguage?: string;
                dependencies?:
                    | { applications: Record<string, { tables?: (...)[] }> }
                    | Record<
                        string,
                        objectInputType<
                            {
                                roles: ZodOptional<ZodUnion<(...)>>;
                                tables: ZodOptional<ZodUnion<(...)>>;
                            },
                            ZodUnion<[ZodLiteral<(...)>, ZodArray<(...), (...)>]>,
                            "strip",
                        >,
                    >;
                description?: string;
                fluentDir?: string;
                generatedDir?: string;
                guidedSetupGuid?: string;
                hostedPlugins?: Record<string, string>;
                ignoreTransformTableList?: string[];
                installedAsDependency?: boolean;
                jsLevel?: string;
                licensing?: {
                    enforceLicense?: string;
                    licensable?: boolean;
                    licenseCategory?: string;
                    licenseModel?: string;
                    subscriptionEntitlement?: string;
                };
                linter?: { module: { enabled?: boolean } };
                logo?: string;
                menu?: string;
                metadataDir?: string;
                moduleDir?: string;
                modulePaths?: Record<string, string>;
                name?: string;
                networkPolicies?: {
                    $id?: string;
                    active?: boolean;
                    host?: string;
                    path?: string[];
                    policyType:
                        | "csp_script_src"
                        | "csp_connect_src"
                        | "now_inbound_scoped"
                        | "now_inbound_global"
                        | "now_outbound";
                    resource?: string;
                    scheme?: "http"
                    | "https"
                    | "ws"
                    | "wss";
                    shortDescription?: string;
                    status: "requested" | "allowed" | "denied";
                }[];
                npmUpdateCheck?: number
                | false;
                packageResolverVersion?: string;
                packOutputDir?: string;
                performancePolicy?: {
                    $id?: string;
                    apiTransactionLimit?: number;
                    eventHandlerLimit?: number;
                    interactiveTransactionLimit?: number;
                    mode?: "disabled" | "enforced" | "logOnly";
                    name: string;
                    scheduledJobLimit?: number;
                };
                scope: string;
                scopeId: string;
                scripts?: Record<string, string>;
                serverModulesDir?: string;
                serverModulesExcludePatterns?: string[];
                serverModulesIncludePatterns?: string[];
                sourceDir?: string;
                staticContentDir?: string;
                staticContentPaths?: Record<string, string>;
                tableDefaultLanguage?: string;
                tableOutputFormat?: "component" | "bootstrap";
                taxonomy?: {
                    fallbackFolderName?: string;
                    mapping?: objectInputType<
                        { [x: string]: ZodDefault<(...)> },
                        ZodString,
                        "strip",
                    >;
                };
                transpiledSourceDir?: string;
                trustedModules?: string[];
                tsconfigPath?: string;
                type?: "configuration"
                | "package";
                typesDir?: string;
                wildcardPolicy?: {
                    $id?: string;
                    active?: boolean;
                    arl?: { active?: boolean; arlWildcard?: (...)[] };
                    network?: { active?: boolean; networkWildcard?: (...)[] };
                    record?: boolean;
                    scripting?: { active?: boolean; scriptingWildcard?: (...)[] };
                    shortDescription?: string;
                };
            },
        >;
        diagnostics?: Diagnostics;
        factory?: Factory;
        fileSystem?: FileSystem;
        inspector?: IInspector;
        keys?: Keys;
        logger?: Logger;
        packageJson?: Package;
        parser?: Parser;
        plugins?: Plugin[]
        | Plugins;
        rootDir?: string;
        sourceFilePaths?: string[];
        targeter?: ITargeter;
        telemetryClient?: Telemetry;
        transform?: Transform;
        transformMode?: "transform" | "type-generation";
    },
): Project

addFile(
    file: File,
    options?: { excludeFromCompiler?: boolean; resolveDependencies?: boolean },
): ProjectFile

addFile(
    path: string,
    options?: { excludeFromCompiler?: boolean; resolveDependencies?: boolean },
): ProjectFile

deleteFile(path: string): void

dispose(): void

findFile(name: string): ProjectFile | undefined

findFile(predicate: (file: ProjectFile) => boolean): ProjectFile | undefined

fix(): Promise<void[]>

format(): Promise<void[]>

getCompiler(): Compiler

getConfig(): {
    accessControls?: {
        canEditInStudio?: boolean;
        hideOnUI?: boolean;
        private?: boolean;
        restrictTableAccess?: boolean;
        runtimeAccessTracking?: string;
        scopedAdministration?: boolean;
        trackable?: boolean;
        uninstallBlocked?: boolean;
        userRole?: string;
    };
    active?: boolean;
    applicationRuntimePolicy: "none"
    | "tracking"
    | "enforcing";
    appOutputDir: string;
    clientDir: string;
    compileOutputDir?: string;
    defaultLanguage: string;
    dependencies?:
        | { applications: Record<string, { tables?: string[] }> }
        | Record<
            string,
            objectOutputType<
                {
                    roles: ZodOptional<
                        ZodUnion<[ZodLiteral<"*">, ZodArray<ZodString, "many">]>,
                    >;
                    tables: ZodOptional<
                        ZodUnion<[ZodLiteral<"*">, ZodArray<ZodString, "many">]>,
                    >;
                },
                ZodUnion<[ZodLiteral<"*">, ZodArray<ZodString, "many">]>,
                "strip",
            >,
        >;
    description?: string;
    fluentDir: string;
    generatedDir: string;
    guidedSetupGuid?: string;
    hostedPlugins?: Record<string, string>;
    ignoreTransformTableList: string[];
    installedAsDependency?: boolean;
    jsLevel?: string;
    licensing?: {
        enforceLicense?: string;
        licensable?: boolean;
        licenseCategory?: string;
        licenseModel?: string;
        subscriptionEntitlement?: string;
    };
    linter: { module: { enabled: boolean } };
    logo?: string;
    menu?: string;
    metadataDir: string;
    moduleDir?: string;
    modulePaths: Record<string, string>;
    name?: string;
    networkPolicies?: {
        $id?: string;
        active: boolean;
        host?: string;
        path?: string[];
        policyType:
            | "csp_script_src"
            | "csp_connect_src"
            | "now_inbound_scoped"
            | "now_inbound_global"
            | "now_outbound";
        resource?: string;
        scheme?: "http"
        | "https"
        | "ws"
        | "wss";
        shortDescription?: string;
        status: "requested" | "allowed" | "denied";
    }[];
    npmUpdateCheck: number
    | false;
    packageResolverVersion?: string;
    packOutputDir: string;
    performancePolicy?: {
        $id?: string;
        apiTransactionLimit?: number;
        eventHandlerLimit?: number;
        interactiveTransactionLimit?: number;
        mode?: "disabled" | "enforced" | "logOnly";
        name: string;
        scheduledJobLimit?: number;
    };
    scope: string;
    scopeId: string;
    scripts: Record<string, string>;
    serverModulesDir: string;
    serverModulesExcludePatterns: string[];
    serverModulesIncludePatterns: string[];
    sourceDir?: string;
    staticContentDir: string;
    staticContentPaths: Record<string, string>;
    tableDefaultLanguage?: string;
    tableOutputFormat?: "component" | "bootstrap";
    taxonomy: { fallbackFolderName: string; mapping: Record<string, string> };
    transpiledSourceDir?: string;
    trustedModules: string[];
    tsconfigPath?: string;
    type: "configuration" | "package";
    typesDir: string;
    wildcardPolicy?: {
        $id?: string;
        active: boolean;
        arl?: {
            active: boolean;
            arlWildcard?: (
                | "scheduled_job_limit"
                | "event_handler"
                | "api_transaction_limit"
                | "interactive_transaction_limit"
            )[];
        };
        network?: {
            active: boolean;
            networkWildcard?: (
                | "csp_script_src"
                | "csp_connect_src"
                | "now_inbound_scoped"
                | "now_inbound_global"
                | "now_outbound"
            )[];
        };
        record: boolean;
        scripting?: {
            active: boolean;
            scriptingWildcard?: ("sys_script_include" | "scriptable")[];
        };
        shortDescription?: string;
    };
}

getContext(): FullContext

getDiagnostics(): Promise<Diagnostic[]>

getDiagnosticsService(): Diagnostics

getEntryPoints(): Promise<ProjectFile[]>

getFactory(): Factory

getFile(path: string): ProjectFile

getFileIfExists(path: string): ProjectFile | undefined

getFiles(): ProjectFile[]

getFileSystem(): FileSystem

getFluentDir(): string

getKeys(): Keys

getLogger(): Logger

getMetadataDir(): string

getOutput(sysIds?: Set<string>, errorOnConflict?: boolean): Promise<File[]>

getPackage(): Package

getPlugins(): Plugins

getRecords(sysIds?: Set<string>, errorOnConflict?: boolean): Promise<Database>

getRootDir(): string

getServerDir(): string

getTelemetryClient(): Telemetry

getTransform(): Transform

handleMetadataCopy(
    file: ProjectFile,
    metadataDirRecordPath?: string,
): ProjectFile

isInDir(dir: string, path: string): boolean

isInFluentDir(path: string): boolean

isInFluentHostedPluginDir(path: string, pluginId?: string): boolean

isInMetadataDir(path: string): boolean

isInRootDir(path: string): boolean

isInServerDir(path: string): boolean

isInUiHtmlContentDir(path: string): boolean

isTypesGenerationMode(): boolean

registerCoalesceId(
    table: string,
    key: CoalesceKeys,
    guidOverride?: string,
): string

registerExplicitId(
    table: string,
    key: string | number,
    guidOverride?: string,
): string

relativePath(...paths: string[]): string

reloadDirectory(path: string, refreshFromFileSystem?: boolean): ProjectFile[]

reloadFile(path: string, refreshFromFileSystem?: boolean): ProjectFile

removeFile(file: ProjectFile): void

removeFile(path: string): void

resolvePath(...paths: string[]): string

save(): void

saveOutput(sysIds?: Set<string>, errorOnConflict?: boolean): Promise<File[]>

transform(
    input:
        | string
        | File
        | Shape<unknown>
        | (string | File | Shape<unknown>)[],
    __namedParameters?: TransformOptions,
): Promise<TransformResult>