type EnvironmentConfig = {
    services?: Record<string, ServiceConfig | null>;
    sharedVariables?: VariableValues;
    volumes?: Record<string, VolumeConfig | null>;
    buckets?: Record<string, BucketConfig | null>;
    groups?: Record<string, GroupConfig | null>;
    privateNetworkDisabled?: boolean | null;
    degraded?: string[] | null;
    stopServices?: string[] | null;
};
type ServiceConfig = {
    source?: ServiceSource | null;
    networking?: ServiceNetworking | null;
    variables?: VariableValues | null;
    build?: BuildConfig | null;
    deploy?: DeployConfig | null;
    configFile?: string | null;
    volumeMounts?: Record<string, VolumeMount | null> | null;
    isDeleted?: boolean | null;
    isCreated?: boolean | null;
    parentServiceId?: string | null;
    groupId?: string | null;
    clusterRole?: "root" | "replica" | "internal" | "edge" | null;
    replicaConfig?: {
        minReplicas?: number | null;
        maxReplicas?: number | null;
        step?: number | null;
        scalable?: boolean | null;
    } | null;
    clusterDisplay?: {
        badge?: string | null;
        badgeVariant?: "primary" | "secondary" | "muted" | null;
    } | null;
};
type ServiceSource = {
    image?: string | null;
    repo?: string | null;
    branch?: string | null;
    commitSha?: string | null;
    upstreamUrl?: string | null;
    rootDirectory?: string | null;
    checkSuites?: boolean | null;
    autoUpdates?: {
        type?: "disabled" | "patch" | "minor" | null;
        schedule?: unknown;
        tagMode?: "semver" | "sha" | null;
    } | null;
};
type ServiceNetworking = {
    serviceDomains?: Record<string, DomainConfig | null> | null;
    customDomains?: Record<string, DomainConfig | null> | null;
    tcpProxies?: Record<string, Record<string, never> | null> | null;
    privateNetworkEndpoint?: string | null;
};
type DomainConfig = {
    port?: number | null;
};
type VariableValues = Record<string, VariableConfig | null>;
type VariableConfig = {
    description?: string | null;
    defaultValue?: string | null;
    isOptional?: boolean | null;
    isSealed?: boolean | null;
    value?: string | null;
    generator?: string | null;
    encryptedValue?: string | null;
    preserveExisting?: boolean | null;
};
type BuildConfig = {
    builder?: "NIXPACKS" | "DOCKERFILE" | "RAILPACK" | "HEROKU" | "PAKETO" | null;
    watchPatterns?: string[] | null;
    buildCommand?: string | null;
    buildEnvironment?: "V2" | "V3" | null;
    dockerfilePath?: string | null;
    nixpacksConfigPath?: string | null;
    nixpacksPlan?: unknown;
    nixpacksVersion?: string | null;
    railpackVersion?: string | null;
};
type DeployConfig = {
    startCommand?: string | null;
    preDeployCommand?: string[] | null;
    numReplicas?: number | null;
    healthcheckPath?: string | null;
    healthcheckTimeout?: number | null;
    sleepApplication?: boolean | null;
    runtime?: string | null;
    registryCredentials?: {
        username?: string;
        password?: string;
    } | null;
    restartPolicyType?: "ON_FAILURE" | "ALWAYS" | "NEVER" | null;
    restartPolicyMaxRetries?: number | null;
    cronSchedule?: string | null;
    region?: string | null;
    multiRegionConfig?: Record<string, {
        numReplicas?: number | null;
        stackerAssignment?: string | null;
    } | null> | null;
    limitOverride?: {
        containers?: {
            cpu?: number | null;
            memoryBytes?: number | null;
            diskBytes?: number | null;
        } | null;
    } | null;
    requiredMountPath?: string | null;
    overlapSeconds?: number | null;
    drainingSeconds?: number | null;
    useLegacyStacker?: boolean | null;
    ipv6EgressEnabled?: boolean | null;
};
type VolumeMount = {
    mountPath?: string | null;
    backupSchedules?: Array<"DAILY" | "WEEKLY" | "MONTHLY"> | null;
};
type VolumeConfig = {
    sizeMB?: number | null;
    region?: string | null;
    alerts?: {
        usage?: Record<string, Record<string, never> | null> | null;
    } | null;
    isDeleted?: boolean | null;
    isCreated?: boolean | null;
    allowOnlineResize?: boolean | null;
    forkFromBaseEnvironment?: boolean | null;
};
type BucketRegion = "sjc" | "iad" | "ams" | "sin";
type BucketConfig = {
    region?: BucketRegion | null;
    isDeleted?: boolean | null;
    isCreated?: boolean | null;
};
type GroupConfig = {
    name?: string | null;
    color?: string | null;
    icon?: string | null;
    isCollapsed?: boolean | null;
    isDeleted?: boolean | null;
    isCreated?: boolean | null;
};

declare const RAILWAY_GRAPH_VERSION: 1;
type GraphVersion = typeof RAILWAY_GRAPH_VERSION;
type ResourceType = "service" | "database" | "volume" | "bucket" | "group";
type ResourceAddress = `${ResourceType}.${string}`;
interface RailwayGraph {
    version: GraphVersion;
    project: ProjectNode;
    environments: EnvironmentNode[];
    resources: ResourceNode[];
    edges: Edge[];
}
interface ProjectNode {
    name: string;
}
interface EnvironmentNode {
    name: string;
}
interface GraphResourceBase {
    /** Deterministic graph handle. Remote Railway IDs live in bindings/lock state. */
    address: ResourceAddress;
    type: ResourceType;
    name: string;
    groupId?: string;
}
type ResourceNode = ServiceNode | DatabaseNode | VolumeNode | BucketNode | GroupNode;
type ServiceKind = "empty" | "github" | "docker-image" | "database" | "function" | "template";
interface SourceConfig extends ServiceSource {
    type: "github" | "image" | "empty" | "template";
    repo?: string | null;
    image?: string | null;
    template?: string | null;
}
interface ServiceNode extends GraphResourceBase {
    address: `service.${string}`;
    type: "service";
    kind: ServiceKind;
    source?: SourceConfig;
    build?: BuildConfig;
    deploy?: DeployConfig;
    networking?: ServiceNetworking;
    variables?: Record<string, VariableValue>;
    volumeMounts?: Record<string, VolumeMount | null>;
    configFile?: string;
    parentServiceId?: string;
    groupId?: string;
    clusterRole?: ServiceConfig["clusterRole"];
    replicaConfig?: ServiceConfig["replicaConfig"];
    clusterDisplay?: ServiceConfig["clusterDisplay"];
}
interface DatabaseNode extends Omit<ServiceNode, "address" | "id" | "type" | "kind"> {
    address: `database.${string}`;
    type: "database";
    kind: "database";
    engine: "postgres" | "mysql" | "redis" | "mongo" | "private";
    image: string;
    output: string;
    defaultMountPath?: string;
}
interface VolumeNode extends GraphResourceBase {
    address: `volume.${string}`;
    type: "volume";
    config?: VolumeConfig;
}
interface BucketNode extends GraphResourceBase {
    address: `bucket.${string}`;
    type: "bucket";
    config?: BucketConfig;
}
interface GroupNode extends GraphResourceBase {
    address: `group.${string}`;
    type: "group";
    color?: string;
    icon?: string;
    isCollapsed?: boolean;
}
type VariableValue = ({
    type: "literal";
} & VariableConfig) | {
    type: "reference";
    resource: ResourceAddress;
    output: string;
} | {
    type: "preserve";
} | {
    type: "raw";
    value: VariableConfig;
};
interface Edge {
    from: ResourceAddress;
    to: ResourceAddress;
    type: "variable" | "mount" | "group";
    key?: string;
}
type ProjectResourceInput = ResourceNode | ResourceNode[];
interface ProjectDefinition {
    name: string;
    environments?: string[];
    resources?: ProjectResourceInput[];
    /** @deprecated Use resources instead. */
    services?: ProjectResourceInput[];
}
interface GraphCompileOptions {
    serviceIdsByName?: Record<string, string>;
    existingServiceIds?: string[];
    volumeIdsByServiceName?: Record<string, string>;
    bucketIdsByName?: Record<string, string>;
}
interface CompileResult {
    graph: RailwayGraph;
    desiredConfig: EnvironmentConfig;
}
interface GraphIndex {
    byAddress: Map<ResourceAddress, ResourceNode>;
    byTypeAndName: Map<`${ResourceType}:${string}`, ResourceNode>;
}
declare function resourceAddress(type: ResourceType, name: string): ResourceAddress;
declare function indexGraph(graph: RailwayGraph): GraphIndex;
declare function validateGraph(graph: RailwayGraph): string[];

declare const RAILWAY_CHANGE_SET_VERSION: 0;
type RailwayChangeSetVersion = typeof RAILWAY_CHANGE_SET_VERSION;
type ChangeSeverity = "safe" | "destructive";
type ChangeDeployEffect = "none" | "deploy" | "unknown";
interface RailwayChangeSet {
    version: RailwayChangeSetVersion;
    changes: RailwayChange[];
    diagnostics: ChangeDiagnostic[];
}
type RailwayChange = CreateResourceChange | DeleteResourceChange | UpdateResourceChange | SetVariableChange | DeleteVariableChange | CreateDomainChange;
interface ChangeBase {
    kind: string;
    path: string;
    summary: string;
    severity: ChangeSeverity;
    deployEffect: ChangeDeployEffect;
}
interface CreateResourceChange extends ChangeBase {
    kind: "resource.create";
    address: ResourceAddress;
    resource: ResourceNode;
}
interface DeleteResourceChange extends ChangeBase {
    kind: "resource.delete";
    address: ResourceAddress;
    previous: ResourceNode;
}
interface UpdateResourceChange extends ChangeBase {
    kind: "resource.update";
    address: ResourceAddress;
    field: string;
    before: unknown;
    after: unknown;
    details?: string[];
}
interface SetVariableChange extends ChangeBase {
    kind: "variable.set";
    address: ResourceAddress;
    variable: string;
    before?: VariableValue | undefined;
    after: VariableValue;
    details?: string[];
}
interface DeleteVariableChange extends ChangeBase {
    kind: "variable.delete";
    address: ResourceAddress;
    variable: string;
    previous: VariableValue;
}
interface CreateDomainChange extends ChangeBase {
    kind: "domain.create";
    address: ResourceAddress;
    domain: string;
    targetPort?: number;
}
interface ChangeDiagnostic {
    severity: "warning" | "error";
    path: string;
    message: string;
}
declare function diffGraphs({ current, desired }: {
    current: RailwayGraph;
    desired: RailwayGraph;
}): RailwayChangeSet;
declare function changeSetToGraph({ current, changeSet }: {
    current: RailwayGraph;
    changeSet: RailwayChangeSet;
}): RailwayGraph;
declare function changeSetToEnvironmentPatch({ currentGraph, currentConfig, changeSet, compileOptions, }: {
    currentGraph: RailwayGraph;
    currentConfig: EnvironmentConfig;
    changeSet: RailwayChangeSet;
    compileOptions?: GraphCompileOptions;
}): EnvironmentConfig;
declare function validateChangeSet(changeSet: RailwayChangeSet): ChangeDiagnostic[];
declare function renderChangeSet(changeSet: RailwayChangeSet): string;

declare const DEFAULT_RAILWAY_GRAPHQL_ENDPOINT = "https://backboard.railway.com/graphql/v2";
type RailwayAuthType = "bearer" | "project-token";
interface RailwayClientConfig {
    token?: string;
    authType?: RailwayAuthType;
    endpoint?: string;
    /** Alias used by IaC flows. Prefer endpoint for the stable SDK surface. */
    graphqlEndpoint?: string;
    fetch?: typeof fetch;
    /**
     * WebSocket constructor used to stream exec output. Defaults to the global
     * `WebSocket` (available in Node >= 22, browsers, Deno, and edge runtimes);
     * pass an implementation (e.g. the `ws` package) where no global exists.
     */
    webSocketImpl?: WebSocketConstructor;
    /**
     * tcp-proxy exec WebSocket endpoint. Defaults to the value derived from
     * `endpoint` (`backboard.<host>` → `wss://ssh.<host>:2226/ws/exec`);
     * override for non-standard deployments.
     */
    tcpProxyWsEndpoint?: string;
    /**
     * Print human-readable progress to stderr (requests, polling, lifecycle).
     * Also enabled by `RAILWAY_VERBOSE`. Tokens and env values are never logged.
     */
    verbose?: boolean;
}
/** Structural constructor type satisfied by native WebSocket and the `ws` package. */
type WebSocketConstructor = new (url: string, protocols?: string | string[]) => unknown;

interface CurrentEnvironmentResult {
    projectId?: string | undefined;
    projectName?: string | undefined;
    environmentId: string;
    environmentName?: string | undefined;
    config: EnvironmentConfig;
    serviceNamesById: Record<string, string>;
    bucketNamesById: Record<string, string>;
    customDomainsByServiceId: Record<string, Record<string, {
        port?: number;
    }>>;
}
interface StagedPatchResult {
    id: string;
    status: string;
    patch: EnvironmentConfig;
    meta?: unknown;
}
interface ChangeOperationResult {
    kind: string;
    path?: string | null;
    summary?: string | null;
    status: string;
    outputs?: unknown;
}
interface ChangeSetPreviewResult {
    changeSet: RailwayChangeSet;
    diagnostics: unknown[];
    effects: unknown[];
}
interface ChangeSetApplyResult {
    id: string;
    status: string;
    changes: ChangeOperationResult[];
    diagnostics: unknown[];
    deploymentId?: string | null;
    stagedPatchId?: string | null;
}
interface ProjectService {
    id: string;
    name: string;
}
interface ProjectVolume {
    id: string;
    name?: string | null;
    serviceId?: string | null;
}
interface ProjectBucket {
    id: string;
    name: string;
}
interface EnsuredGraphResources {
    serviceIdsByName: Record<string, string>;
    volumeIdsByServiceName: Record<string, string>;
    bucketIdsByName: Record<string, string>;
}
declare class IacClient {
    #private;
    constructor(config: RailwayClientConfig);
    getCurrentEnvironment(environmentId: string, options?: {
        decryptVariables?: boolean;
    }): Promise<CurrentEnvironmentResult>;
    getStagedPatch(environmentId: string, options?: {
        decryptVariables?: boolean;
    }): Promise<StagedPatchResult>;
    getProjectName(projectId: string): Promise<string | undefined>;
    getProjectServices(projectId: string): Promise<ProjectService[]>;
    getProjectBuckets(projectId: string): Promise<ProjectBucket[]>;
    getEnvironmentCustomDomains(projectId: string, environmentId: string, services: ProjectService[]): Promise<Record<string, Record<string, {
        port?: number;
    }>>>;
    ensureGraphResources({ projectId, environmentId, graph, currentConfig }: {
        projectId: string;
        environmentId: string;
        graph: RailwayGraph;
        currentConfig?: EnvironmentConfig;
    }): Promise<EnsuredGraphResources>;
    stageEnvironmentChanges({ environmentId, patch, merge }: {
        environmentId: string;
        patch: EnvironmentConfig;
        merge?: boolean;
    }): Promise<{
        id: string;
    }>;
    previewChangeSet({ environmentId, changeSet }: {
        environmentId: string;
        changeSet: RailwayChangeSet;
    }): Promise<ChangeSetPreviewResult>;
    applyChangeSet({ environmentId, changeSet, commitMessage }: {
        environmentId: string;
        changeSet: RailwayChangeSet;
        commitMessage?: string;
    }): Promise<ChangeSetApplyResult>;
    commitStagedPatch({ environmentId, message, skipDeploys }: {
        environmentId: string;
        message?: string;
        skipDeploys?: boolean;
    }): Promise<string>;
    private ensureGraphBuckets;
    private createBucketForResource;
    private createVolumeForService;
    private createServiceForResource;
}

declare function projectDefinitionToGraph(definition: ProjectDefinition): RailwayGraph;
declare function graphToEnvironmentConfig(graph: RailwayGraph, options?: GraphCompileOptions): EnvironmentConfig;
declare function environmentConfigToGraph(config: EnvironmentConfig, options?: {
    projectName?: string;
    serviceNamesById?: Record<string, string>;
    bucketNamesById?: Record<string, string>;
    customDomainsByServiceId?: Record<string, Record<string, {
        port?: number;
    }>>;
}): RailwayGraph;
declare function composePatch({ currentConfig, desiredConfig }: {
    currentConfig: EnvironmentConfig;
    desiredConfig: EnvironmentConfig;
}): EnvironmentConfig;

declare function renderPatchDiff({ currentConfig, patch, title, }: {
    currentConfig: EnvironmentConfig;
    patch: EnvironmentConfig;
    title?: string;
}): string;
declare function numChangesInEnvironmentConfig(config: EnvironmentConfig): number;

interface RailwayContextInput {
    command?: string;
    projectId?: string;
    projectName?: string;
    environmentId?: string;
    environment?: string;
    environmentName?: string;
}
interface RailwayContext extends RailwayContextInput {
    randomString: (label?: string, bytes?: number) => string;
    isEnvironment: (name: string) => boolean;
}
type RailwayProgram = (ctx: RailwayContext, project: (name: string, definition: Omit<ProjectDefinition, "name">) => ProjectDefinition) => ProjectDefinition | Promise<ProjectDefinition>;
declare function defineRailway(program: RailwayProgram): RailwayProgram;
declare const define: typeof defineRailway;
declare function project(name: string, definition: Omit<ProjectDefinition, "name">): ProjectDefinition;
declare function createRailwayContext(input?: RailwayContextInput): RailwayContext;
type RegionConfig = number | {
    count?: number;
    replicas?: number;
    stacker?: string | null;
};
interface IntentServiceConfig {
    source?: SourceConfig | Omit<SourceConfig, "type">;
    root?: string;
    rootDirectory?: string;
    build?: string | BuildConfig;
    deploy?: DeployConfig;
    run?: {
        command?: string;
        preDeploy?: string | string[];
        healthcheck?: string;
        healthcheckTimeout?: number;
    };
    start?: string;
    startCommand?: string;
    preDeploy?: string | string[];
    preDeployCommand?: string | string[];
    healthcheck?: string;
    healthcheckPath?: string;
    healthcheckTimeout?: number;
    replicas?: number | Record<string, RegionConfig>;
    regions?: Record<string, RegionConfig>;
    networking?: ServiceNetworking;
    domains?: Array<string | {
        domain: string;
        port?: number;
    }>;
    tcp?: Array<string | number>;
    tcpProxies?: string[];
    env?: Record<string, string | VariableConfig | VariableValue>;
    variables?: Record<string, string | VariableConfig | VariableValue>;
    volumeMounts?: Record<string, VolumeMount | null>;
    configFile?: string;
    parentServiceId?: string;
    groupId?: string;
    clusterRole?: ServiceConfig["clusterRole"];
    replicaConfig?: ServiceConfig["replicaConfig"];
    clusterDisplay?: ServiceConfig["clusterDisplay"];
}
type ServiceConfigInput = IntentServiceConfig;
type RailwayProvidedVariable = "RAILWAY_PUBLIC_DOMAIN" | "RAILWAY_PRIVATE_DOMAIN" | "RAILWAY_TCP_PROXY_DOMAIN" | "RAILWAY_TCP_PROXY_PORT" | "RAILWAY_DEPLOYMENT_ID" | "RAILWAY_DEPLOYMENT_DRAINING_SECONDS" | "RAILWAY_ENVIRONMENT" | "RAILWAY_ENVIRONMENT_ID" | "RAILWAY_PROJECT_ID" | "RAILWAY_PROJECT_NAME" | "RAILWAY_SERVICE_ID" | "RAILWAY_SERVICE_NAME" | "RAILWAY_REPLICA_ID" | "PORT";
type PostgresVariable = RailwayProvidedVariable | "DATABASE_PUBLIC_URL" | "DATABASE_URL" | "PGDATA" | "PGDATABASE" | "PGHOST" | "PGPASSWORD" | "PGPORT" | "PGUSER" | "POSTGRES_DB" | "POSTGRES_PASSWORD" | "POSTGRES_USER" | "SSL_CERT_DAYS";
type RedisVariable = RailwayProvidedVariable | "REDIS_PASSWORD" | "REDIS_PUBLIC_URL" | "REDIS_URL" | "REDISHOST" | "REDISPASSWORD" | "REDISPORT" | "REDISUSER";
type MongoVariable = RailwayProvidedVariable | "MONGO_INITDB_ROOT_PASSWORD" | "MONGO_INITDB_ROOT_USERNAME" | "MONGO_PUBLIC_URL" | "MONGO_URL" | "MONGOHOST" | "MONGOPASSWORD" | "MONGOPORT" | "MONGOUSER";
type MySqlVariable = RailwayProvidedVariable | "MYSQL_DATABASE" | "MYSQL_PUBLIC_URL" | "MYSQL_ROOT_PASSWORD" | "MYSQL_URL" | "MYSQLDATABASE" | "MYSQLHOST" | "MYSQLPASSWORD" | "MYSQLPORT" | "MYSQLUSER";
type DatabaseVariable<E extends DatabaseNode["engine"]> = E extends "postgres" ? PostgresVariable : E extends "redis" ? RedisVariable : E extends "mongo" ? MongoVariable : E extends "mysql" ? MySqlVariable : RailwayProvidedVariable | string;
type ServiceVariableRef<K extends string = RailwayProvidedVariable | string> = {
    readonly [P in K]: VariableValue;
};
type ReferencableServiceNode<K extends string = RailwayProvidedVariable | string> = ServiceNode & {
    readonly env: ServiceVariableRef<K>;
};
type ReferencableDatabaseNode<E extends DatabaseNode["engine"]> = DatabaseNode & {
    readonly env: ServiceVariableRef<DatabaseVariable<E>>;
};
declare function github(repo: string, options?: Omit<SourceConfig, "type" | "repo" | "image">): SourceConfig;
declare function image(imageName: string, options?: Pick<SourceConfig, "rootDirectory" | "autoUpdates">): SourceConfig;
declare function template(templateName: string, options?: Omit<SourceConfig, "type" | "template">): SourceConfig;
declare function empty(): SourceConfig;
declare function service<const Env extends Record<string, string | VariableConfig | VariableValue> = {}>(name: string, config?: Omit<ServiceConfigInput, "env" | "variables"> & {
    env?: Env;
    variables?: Env;
}): ReferencableServiceNode<RailwayProvidedVariable | Extract<keyof Env, string>>;
declare function fn<const Env extends Record<string, string | VariableConfig | VariableValue> = {}>(name: string, config?: Omit<ServiceConfigInput, "env" | "variables"> & {
    env?: Env;
    variables?: Env;
}): ReferencableServiceNode<RailwayProvidedVariable | Extract<keyof Env, string>>;
interface DatabaseConfig {
    region?: string;
}
declare function postgres(name: string, config?: DatabaseConfig): ReferencableDatabaseNode<"postgres">;
declare function mysql(name: string, config?: DatabaseConfig): ReferencableDatabaseNode<"mysql">;
declare function redis(name: string, config?: DatabaseConfig): ReferencableDatabaseNode<"redis">;
declare function mongo(name: string, config?: DatabaseConfig): ReferencableDatabaseNode<"mongo">;
declare function database<E extends DatabaseNode["engine"]>(name: string, engine: E, options: {
    image: string;
    output?: string;
    defaultMountPath?: string;
    region?: string;
}): ReferencableDatabaseNode<E>;
declare function volume(name: string, config?: VolumeConfig): VolumeNode;
declare function bucket(name: string, config?: BucketConfig): BucketNode;
declare function group(name: string, resources: ProjectResourceInput[], options?: Omit<GroupNode, "address" | "type" | "name">): ResourceNode[];
declare function group(name: string, options?: Omit<GroupNode, "address" | "type" | "name">): GroupNode;
declare function ref(resource: ResourceNode, output: string): VariableValue;
declare function preserve(): VariableValue;

declare function evaluateRailwayFile(filePath: string, options?: GraphCompileOptions & {
    context?: RailwayContextInput;
}): Promise<CompileResult>;

interface RailwayIacServiceMap {
}
interface RailwayIacDatabaseMap {
}
interface RailwayIacBucketMap {
}
interface RailwayIacVolumeMap {
}
interface RailwayIacResourceMap {
}
type KnownName<T> = [keyof T] extends [never] ? string : Extract<keyof T, string>;
type RailwayServiceName = KnownName<RailwayIacServiceMap>;
type RailwayDatabaseName = KnownName<RailwayIacDatabaseMap>;
type RailwayBucketName = KnownName<RailwayIacBucketMap>;
type RailwayVolumeName = KnownName<RailwayIacVolumeMap>;
type RailwayResourceName = KnownName<RailwayIacResourceMap>;
interface EvaluatedRailwayProjectOptions extends GraphCompileOptions {
    file?: string;
    cwd?: string;
    context?: RailwayContextInput;
}
interface EvaluatedRailwayProjectSnapshot {
    file: string;
    graph: RailwayGraph;
    desiredConfig: EnvironmentConfig;
}
declare function evaluateRailwayProject(options?: EvaluatedRailwayProjectOptions): Promise<EvaluatedRailwayProject>;
declare function findRailwayFile(cwd?: string): string;
declare class EvaluatedRailwayProject {
    readonly file: string;
    readonly graph: RailwayGraph;
    readonly desiredConfig: EnvironmentConfig;
    constructor(snapshot: EvaluatedRailwayProjectSnapshot);
    get name(): string;
    get resources(): ResourceNode[];
    get services(): Array<ServiceNode | DatabaseNode>;
    resource(name: RailwayResourceName): ResourceNode;
    service(name: RailwayServiceName): ServiceNode | DatabaseNode;
    database(name: RailwayDatabaseName): DatabaseNode;
    bucket(name: RailwayBucketName): BucketNode;
    volume(name: RailwayVolumeName): VolumeNode;
    config(options?: GraphCompileOptions): EnvironmentConfig;
    toJSON(): EvaluatedRailwayProjectSnapshot;
}

interface RailwayIacRunnerRequest {
    command?: "evaluate" | "typegen" | "current" | "plan" | "stage" | "apply";
    cwd?: string;
    file?: string;
    includeTypes?: boolean;
    pretty?: boolean;
    context?: RailwayContextInput;
    backboard?: RailwayIacBackboardContext;
}
interface RailwayIacBackboardContext {
    endpoint?: string;
    token?: string;
    authType?: RailwayAuthType;
    projectId?: string;
    environmentId?: string;
    decryptVariables?: boolean;
    merge?: boolean;
}
interface RailwayIacRunnerDiagnostic {
    severity: "warning" | "error";
    path: string;
    message: string;
}
interface RailwayIacEvaluateResponse {
    ok: boolean;
    command: "evaluate";
    file: string;
    graph?: RailwayGraph;
    graphTypes?: string;
    diagnostics: RailwayIacRunnerDiagnostic[];
}
interface RailwayIacTypegenResponse {
    ok: boolean;
    command: "typegen";
    file: string;
    graphTypes?: string;
    diagnostics: RailwayIacRunnerDiagnostic[];
}
interface RailwayIacCurrentResponse {
    ok: boolean;
    command: "current";
    file: string;
    mode: "real";
    currentGraph?: RailwayGraph;
    currentConfig?: EnvironmentConfig;
    currentEnvironment?: Omit<CurrentEnvironmentResult, "config">;
    graphTypes?: string;
    diagnostics: RailwayIacRunnerDiagnostic[];
}
interface RailwayIacPlanResponse {
    ok: boolean;
    command: "plan";
    file: string;
    mode: "real";
    currentGraph?: RailwayGraph;
    desiredGraph?: RailwayGraph;
    currentConfig?: EnvironmentConfig;
    currentEnvironment?: Omit<CurrentEnvironmentResult, "config">;
    changeSet?: RailwayChangeSet;
    preview?: ChangeSetPreviewResult;
    diff?: string;
    graphTypes?: string;
    diagnostics: RailwayIacRunnerDiagnostic[];
}
interface RailwayIacStageResponse extends Omit<RailwayIacPlanResponse, "command"> {
    command: "stage";
}
interface RailwayIacApplyResponse extends Omit<RailwayIacStageResponse, "command"> {
    command: "apply";
    applyResult?: ChangeSetApplyResult;
    deploymentId?: string;
    stagedPatchId?: string;
}
type RailwayIacRunnerResponse = RailwayIacEvaluateResponse | RailwayIacTypegenResponse | RailwayIacCurrentResponse | RailwayIacPlanResponse | RailwayIacStageResponse | RailwayIacApplyResponse;
declare function runRailwayIac(request?: RailwayIacRunnerRequest): Promise<RailwayIacRunnerResponse>;

declare function renderRailwayGraphTypes(graph: RailwayGraph): string;

type index_BucketConfig = BucketConfig;
type index_BucketNode = BucketNode;
type index_BucketRegion = BucketRegion;
type index_BuildConfig = BuildConfig;
type index_ChangeBase = ChangeBase;
type index_ChangeDeployEffect = ChangeDeployEffect;
type index_ChangeDiagnostic = ChangeDiagnostic;
type index_ChangeOperationResult = ChangeOperationResult;
type index_ChangeSetApplyResult = ChangeSetApplyResult;
type index_ChangeSetPreviewResult = ChangeSetPreviewResult;
type index_ChangeSeverity = ChangeSeverity;
type index_CompileResult = CompileResult;
type index_CreateDomainChange = CreateDomainChange;
type index_CreateResourceChange = CreateResourceChange;
type index_CurrentEnvironmentResult = CurrentEnvironmentResult;
type index_DatabaseConfig = DatabaseConfig;
type index_DatabaseNode = DatabaseNode;
type index_DatabaseVariable<E extends DatabaseNode["engine"]> = DatabaseVariable<E>;
type index_DeleteResourceChange = DeleteResourceChange;
type index_DeleteVariableChange = DeleteVariableChange;
type index_DeployConfig = DeployConfig;
type index_DomainConfig = DomainConfig;
type index_Edge = Edge;
type index_EnsuredGraphResources = EnsuredGraphResources;
type index_EnvironmentConfig = EnvironmentConfig;
type index_EnvironmentNode = EnvironmentNode;
type index_EvaluatedRailwayProject = EvaluatedRailwayProject;
declare const index_EvaluatedRailwayProject: typeof EvaluatedRailwayProject;
type index_EvaluatedRailwayProjectOptions = EvaluatedRailwayProjectOptions;
type index_EvaluatedRailwayProjectSnapshot = EvaluatedRailwayProjectSnapshot;
type index_GraphCompileOptions = GraphCompileOptions;
type index_GraphIndex = GraphIndex;
type index_GraphResourceBase = GraphResourceBase;
type index_GraphVersion = GraphVersion;
type index_GroupConfig = GroupConfig;
type index_GroupNode = GroupNode;
type index_IacClient = IacClient;
declare const index_IacClient: typeof IacClient;
type index_IntentServiceConfig = IntentServiceConfig;
type index_MongoVariable = MongoVariable;
type index_MySqlVariable = MySqlVariable;
type index_PostgresVariable = PostgresVariable;
type index_ProjectBucket = ProjectBucket;
type index_ProjectDefinition = ProjectDefinition;
type index_ProjectNode = ProjectNode;
type index_ProjectResourceInput = ProjectResourceInput;
type index_ProjectService = ProjectService;
type index_ProjectVolume = ProjectVolume;
declare const index_RAILWAY_CHANGE_SET_VERSION: typeof RAILWAY_CHANGE_SET_VERSION;
declare const index_RAILWAY_GRAPH_VERSION: typeof RAILWAY_GRAPH_VERSION;
type index_RailwayBucketName = RailwayBucketName;
type index_RailwayChange = RailwayChange;
type index_RailwayChangeSet = RailwayChangeSet;
type index_RailwayChangeSetVersion = RailwayChangeSetVersion;
type index_RailwayContext = RailwayContext;
type index_RailwayContextInput = RailwayContextInput;
type index_RailwayDatabaseName = RailwayDatabaseName;
type index_RailwayGraph = RailwayGraph;
type index_RailwayIacApplyResponse = RailwayIacApplyResponse;
type index_RailwayIacBackboardContext = RailwayIacBackboardContext;
type index_RailwayIacBucketMap = RailwayIacBucketMap;
type index_RailwayIacCurrentResponse = RailwayIacCurrentResponse;
type index_RailwayIacDatabaseMap = RailwayIacDatabaseMap;
type index_RailwayIacEvaluateResponse = RailwayIacEvaluateResponse;
type index_RailwayIacPlanResponse = RailwayIacPlanResponse;
type index_RailwayIacResourceMap = RailwayIacResourceMap;
type index_RailwayIacRunnerDiagnostic = RailwayIacRunnerDiagnostic;
type index_RailwayIacRunnerRequest = RailwayIacRunnerRequest;
type index_RailwayIacRunnerResponse = RailwayIacRunnerResponse;
type index_RailwayIacServiceMap = RailwayIacServiceMap;
type index_RailwayIacStageResponse = RailwayIacStageResponse;
type index_RailwayIacTypegenResponse = RailwayIacTypegenResponse;
type index_RailwayIacVolumeMap = RailwayIacVolumeMap;
type index_RailwayProgram = RailwayProgram;
type index_RailwayProvidedVariable = RailwayProvidedVariable;
type index_RailwayResourceName = RailwayResourceName;
type index_RailwayServiceName = RailwayServiceName;
type index_RailwayVolumeName = RailwayVolumeName;
type index_RedisVariable = RedisVariable;
type index_ReferencableDatabaseNode<E extends DatabaseNode["engine"]> = ReferencableDatabaseNode<E>;
type index_ReferencableServiceNode<K extends string = RailwayProvidedVariable | string> = ReferencableServiceNode<K>;
type index_RegionConfig = RegionConfig;
type index_ResourceAddress = ResourceAddress;
type index_ResourceNode = ResourceNode;
type index_ResourceType = ResourceType;
type index_ServiceConfig = ServiceConfig;
type index_ServiceConfigInput = ServiceConfigInput;
type index_ServiceKind = ServiceKind;
type index_ServiceNetworking = ServiceNetworking;
type index_ServiceNode = ServiceNode;
type index_ServiceSource = ServiceSource;
type index_ServiceVariableRef<K extends string = RailwayProvidedVariable | string> = ServiceVariableRef<K>;
type index_SetVariableChange = SetVariableChange;
type index_SourceConfig = SourceConfig;
type index_StagedPatchResult = StagedPatchResult;
type index_UpdateResourceChange = UpdateResourceChange;
type index_VariableConfig = VariableConfig;
type index_VariableValue = VariableValue;
type index_VariableValues = VariableValues;
type index_VolumeConfig = VolumeConfig;
type index_VolumeMount = VolumeMount;
type index_VolumeNode = VolumeNode;
declare const index_bucket: typeof bucket;
declare const index_changeSetToEnvironmentPatch: typeof changeSetToEnvironmentPatch;
declare const index_changeSetToGraph: typeof changeSetToGraph;
declare const index_composePatch: typeof composePatch;
declare const index_createRailwayContext: typeof createRailwayContext;
declare const index_database: typeof database;
declare const index_define: typeof define;
declare const index_defineRailway: typeof defineRailway;
declare const index_diffGraphs: typeof diffGraphs;
declare const index_empty: typeof empty;
declare const index_environmentConfigToGraph: typeof environmentConfigToGraph;
declare const index_evaluateRailwayFile: typeof evaluateRailwayFile;
declare const index_evaluateRailwayProject: typeof evaluateRailwayProject;
declare const index_findRailwayFile: typeof findRailwayFile;
declare const index_fn: typeof fn;
declare const index_github: typeof github;
declare const index_graphToEnvironmentConfig: typeof graphToEnvironmentConfig;
declare const index_group: typeof group;
declare const index_image: typeof image;
declare const index_indexGraph: typeof indexGraph;
declare const index_mongo: typeof mongo;
declare const index_mysql: typeof mysql;
declare const index_numChangesInEnvironmentConfig: typeof numChangesInEnvironmentConfig;
declare const index_postgres: typeof postgres;
declare const index_preserve: typeof preserve;
declare const index_project: typeof project;
declare const index_projectDefinitionToGraph: typeof projectDefinitionToGraph;
declare const index_redis: typeof redis;
declare const index_ref: typeof ref;
declare const index_renderChangeSet: typeof renderChangeSet;
declare const index_renderPatchDiff: typeof renderPatchDiff;
declare const index_renderRailwayGraphTypes: typeof renderRailwayGraphTypes;
declare const index_resourceAddress: typeof resourceAddress;
declare const index_runRailwayIac: typeof runRailwayIac;
declare const index_service: typeof service;
declare const index_template: typeof template;
declare const index_validateChangeSet: typeof validateChangeSet;
declare const index_validateGraph: typeof validateGraph;
declare const index_volume: typeof volume;
declare namespace index {
  export { type index_BucketConfig as BucketConfig, type index_BucketNode as BucketNode, type index_BucketRegion as BucketRegion, type index_BuildConfig as BuildConfig, type index_ChangeBase as ChangeBase, type index_ChangeDeployEffect as ChangeDeployEffect, type index_ChangeDiagnostic as ChangeDiagnostic, type index_ChangeOperationResult as ChangeOperationResult, type index_ChangeSetApplyResult as ChangeSetApplyResult, type index_ChangeSetPreviewResult as ChangeSetPreviewResult, type index_ChangeSeverity as ChangeSeverity, type index_CompileResult as CompileResult, type index_CreateDomainChange as CreateDomainChange, type index_CreateResourceChange as CreateResourceChange, type index_CurrentEnvironmentResult as CurrentEnvironmentResult, type index_DatabaseConfig as DatabaseConfig, type index_DatabaseNode as DatabaseNode, type index_DatabaseVariable as DatabaseVariable, type index_DeleteResourceChange as DeleteResourceChange, type index_DeleteVariableChange as DeleteVariableChange, type index_DeployConfig as DeployConfig, type index_DomainConfig as DomainConfig, type index_Edge as Edge, type index_EnsuredGraphResources as EnsuredGraphResources, type index_EnvironmentConfig as EnvironmentConfig, type index_EnvironmentNode as EnvironmentNode, index_EvaluatedRailwayProject as EvaluatedRailwayProject, type index_EvaluatedRailwayProjectOptions as EvaluatedRailwayProjectOptions, type index_EvaluatedRailwayProjectSnapshot as EvaluatedRailwayProjectSnapshot, type index_GraphCompileOptions as GraphCompileOptions, type index_GraphIndex as GraphIndex, type index_GraphResourceBase as GraphResourceBase, type index_GraphVersion as GraphVersion, type index_GroupConfig as GroupConfig, type index_GroupNode as GroupNode, index_IacClient as IacClient, type index_IntentServiceConfig as IntentServiceConfig, type index_MongoVariable as MongoVariable, type index_MySqlVariable as MySqlVariable, type index_PostgresVariable as PostgresVariable, type index_ProjectBucket as ProjectBucket, type index_ProjectDefinition as ProjectDefinition, type index_ProjectNode as ProjectNode, type index_ProjectResourceInput as ProjectResourceInput, type index_ProjectService as ProjectService, type index_ProjectVolume as ProjectVolume, index_RAILWAY_CHANGE_SET_VERSION as RAILWAY_CHANGE_SET_VERSION, index_RAILWAY_GRAPH_VERSION as RAILWAY_GRAPH_VERSION, type index_RailwayBucketName as RailwayBucketName, type index_RailwayChange as RailwayChange, type index_RailwayChangeSet as RailwayChangeSet, type index_RailwayChangeSetVersion as RailwayChangeSetVersion, type index_RailwayContext as RailwayContext, type index_RailwayContextInput as RailwayContextInput, type index_RailwayDatabaseName as RailwayDatabaseName, type index_RailwayGraph as RailwayGraph, type index_RailwayIacApplyResponse as RailwayIacApplyResponse, type index_RailwayIacBackboardContext as RailwayIacBackboardContext, type index_RailwayIacBucketMap as RailwayIacBucketMap, type index_RailwayIacCurrentResponse as RailwayIacCurrentResponse, type index_RailwayIacDatabaseMap as RailwayIacDatabaseMap, type index_RailwayIacEvaluateResponse as RailwayIacEvaluateResponse, type index_RailwayIacPlanResponse as RailwayIacPlanResponse, type index_RailwayIacResourceMap as RailwayIacResourceMap, type index_RailwayIacRunnerDiagnostic as RailwayIacRunnerDiagnostic, type index_RailwayIacRunnerRequest as RailwayIacRunnerRequest, type index_RailwayIacRunnerResponse as RailwayIacRunnerResponse, type index_RailwayIacServiceMap as RailwayIacServiceMap, type index_RailwayIacStageResponse as RailwayIacStageResponse, type index_RailwayIacTypegenResponse as RailwayIacTypegenResponse, type index_RailwayIacVolumeMap as RailwayIacVolumeMap, type index_RailwayProgram as RailwayProgram, type index_RailwayProvidedVariable as RailwayProvidedVariable, type index_RailwayResourceName as RailwayResourceName, type index_RailwayServiceName as RailwayServiceName, type index_RailwayVolumeName as RailwayVolumeName, type index_RedisVariable as RedisVariable, type index_ReferencableDatabaseNode as ReferencableDatabaseNode, type index_ReferencableServiceNode as ReferencableServiceNode, type index_RegionConfig as RegionConfig, type index_ResourceAddress as ResourceAddress, type index_ResourceNode as ResourceNode, type index_ResourceType as ResourceType, type index_ServiceConfig as ServiceConfig, type index_ServiceConfigInput as ServiceConfigInput, type index_ServiceKind as ServiceKind, type index_ServiceNetworking as ServiceNetworking, type index_ServiceNode as ServiceNode, type index_ServiceSource as ServiceSource, type index_ServiceVariableRef as ServiceVariableRef, type index_SetVariableChange as SetVariableChange, type index_SourceConfig as SourceConfig, type index_StagedPatchResult as StagedPatchResult, type index_UpdateResourceChange as UpdateResourceChange, type index_VariableConfig as VariableConfig, type index_VariableValue as VariableValue, type index_VariableValues as VariableValues, type index_VolumeConfig as VolumeConfig, type index_VolumeMount as VolumeMount, type index_VolumeNode as VolumeNode, index_bucket as bucket, index_changeSetToEnvironmentPatch as changeSetToEnvironmentPatch, index_changeSetToGraph as changeSetToGraph, index_composePatch as composePatch, index_createRailwayContext as createRailwayContext, index_database as database, index_define as define, index_defineRailway as defineRailway, index_diffGraphs as diffGraphs, index_empty as empty, index_environmentConfigToGraph as environmentConfigToGraph, index_evaluateRailwayFile as evaluateRailwayFile, index_evaluateRailwayProject as evaluateRailwayProject, index_findRailwayFile as findRailwayFile, index_fn as fn, index_github as github, index_graphToEnvironmentConfig as graphToEnvironmentConfig, index_group as group, index_image as image, index_indexGraph as indexGraph, index_mongo as mongo, index_mysql as mysql, index_numChangesInEnvironmentConfig as numChangesInEnvironmentConfig, index_postgres as postgres, index_preserve as preserve, index_project as project, index_projectDefinitionToGraph as projectDefinitionToGraph, index_redis as redis, index_ref as ref, index_renderChangeSet as renderChangeSet, index_renderPatchDiff as renderPatchDiff, index_renderRailwayGraphTypes as renderRailwayGraphTypes, index_resourceAddress as resourceAddress, index_runRailwayIac as runRailwayIac, index_service as service, index_template as template, index_validateChangeSet as validateChangeSet, index_validateGraph as validateGraph, index_volume as volume };
}

export { project as $, defineRailway as A, type BucketConfig as B, type ChangeDeployEffect as C, DEFAULT_RAILWAY_GRAPHQL_ENDPOINT as D, type EnvironmentConfig as E, diffGraphs as F, type GraphCompileOptions as G, empty as H, IacClient as I, environmentConfigToGraph as J, evaluateRailwayFile as K, evaluateRailwayProject as L, findRailwayFile as M, fn as N, github as O, type ProjectDefinition as P, graphToEnvironmentConfig as Q, type RailwayClientConfig as R, type ServiceConfigInput as S, group as T, index as U, type VariableValue as V, image as W, indexGraph as X, mongo as Y, mysql as Z, postgres as _, type BucketNode as a, type RailwayVolumeName as a$, redis as a0, ref as a1, renderChangeSet as a2, renderPatchDiff as a3, renderRailwayGraphTypes as a4, resourceAddress as a5, service as a6, template as a7, validateChangeSet as a8, validateGraph as a9, type PostgresVariable as aA, type ProjectBucket as aB, type ProjectResourceInput as aC, type ProjectService as aD, type ProjectVolume as aE, RAILWAY_CHANGE_SET_VERSION as aF, type RailwayBucketName as aG, type RailwayChangeSetVersion as aH, type RailwayContext as aI, type RailwayContextInput as aJ, type RailwayDatabaseName as aK, type RailwayIacApplyResponse as aL, type RailwayIacBackboardContext as aM, type RailwayIacBucketMap as aN, type RailwayIacCurrentResponse as aO, type RailwayIacDatabaseMap as aP, type RailwayIacEvaluateResponse as aQ, type RailwayIacPlanResponse as aR, type RailwayIacResourceMap as aS, type RailwayIacRunnerDiagnostic as aT, type RailwayIacRunnerRequest as aU, type RailwayIacRunnerResponse as aV, type RailwayIacServiceMap as aW, type RailwayIacStageResponse as aX, type RailwayIacTypegenResponse as aY, type RailwayIacVolumeMap as aZ, type RailwayProvidedVariable as a_, volume as aa, type BuildConfig as ab, type ChangeBase as ac, type ChangeOperationResult as ad, type ChangeSetApplyResult as ae, type ChangeSetPreviewResult as af, type CreateDomainChange as ag, type CreateResourceChange as ah, type CurrentEnvironmentResult as ai, type DatabaseVariable as aj, type DeleteResourceChange as ak, type DeleteVariableChange as al, type DeployConfig as am, type DomainConfig as an, type Edge as ao, type EnsuredGraphResources as ap, type EnvironmentNode as aq, type EvaluatedRailwayProjectOptions as ar, type EvaluatedRailwayProjectSnapshot as as, type GraphResourceBase as at, type GraphVersion as au, type GroupConfig as av, type GroupNode as aw, type IntentServiceConfig as ax, type MongoVariable as ay, type MySqlVariable as az, type BucketRegion as b, type RedisVariable as b0, type ReferencableDatabaseNode as b1, type ReferencableServiceNode as b2, type RegionConfig as b3, type ResourceType as b4, type ServiceConfig as b5, type ServiceKind as b6, type ServiceNetworking as b7, type ServiceSource as b8, type ServiceVariableRef as b9, type SetVariableChange as ba, type SourceConfig as bb, type StagedPatchResult as bc, type UpdateResourceChange as bd, type VariableConfig as be, type VariableValues as bf, type VolumeConfig as bg, type VolumeMount as bh, type VolumeNode as bi, composePatch as bj, numChangesInEnvironmentConfig as bk, preserve as bl, projectDefinitionToGraph as bm, runRailwayIac as bn, type ChangeDiagnostic as c, type ChangeSeverity as d, type CompileResult as e, type DatabaseConfig as f, type DatabaseNode as g, EvaluatedRailwayProject as h, type GraphIndex as i, type ProjectNode as j, RAILWAY_GRAPH_VERSION as k, type RailwayChange as l, type RailwayChangeSet as m, type RailwayGraph as n, type RailwayProgram as o, type RailwayResourceName as p, type RailwayServiceName as q, type ResourceAddress as r, type ResourceNode as s, type ServiceNode as t, bucket as u, changeSetToEnvironmentPatch as v, changeSetToGraph as w, createRailwayContext as x, database as y, define as z };