@setbase/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,783 @@
+import { ProviderCredentials, ProjectState, Manifest, DeploymentConfig, DeploymentOptions, DeploymentResult, Provider, ResourceType, ValidationResult as ValidationResult$1, ProvisionResult, UpdateResult, ResourceStatus, DatabaseConfig, DatabaseOutputs, CacheConfig, CacheOutputs, StorageConfig, StorageOutputs, EmailConfig, EmailOutputs, ComputeConfig, ComputeOutputs } from './types/index.js';
+export { CorsConfig, CredentialsFile, Deployment, DeploymentState, DeploymentStatus, Project, ProjectConfig, ProjectDestroyOptions, ProjectInitOptions, ProviderMetadata, Resource, ResourceConfig, ResourceDefinition, ResourceDefinitions, ResourceOutputs, ResourceState, StateFile } from './types/index.js';
+import { z } from 'zod';
+
+/**
+ * Credential store - securely manages provider credentials
+ */
+
+interface CredentialStore {
+    /**
+     * Save provider credentials
+     */
+    save(providerId: string, credentials: ProviderCredentials): Promise<void>;
+    /**
+     * Load provider credentials
+     */
+    load(providerId: string): Promise<ProviderCredentials | null>;
+    /**
+     * Delete provider credentials
+     */
+    delete(providerId: string): Promise<void>;
+    /**
+     * Check if credentials exist for a provider
+     */
+    has(providerId: string): Promise<boolean>;
+    /**
+     * List all provider IDs with credentials
+     */
+    list(): Promise<string[]>;
+}
+declare class EncryptedCredentialStore implements CredentialStore {
+    private readonly credentialsFilePath;
+    private readonly passphrase;
+    private readonly algorithm;
+    private readonly keyLength;
+    private readonly ivLength;
+    private readonly saltLength;
+    private readonly tagLength;
+    constructor(credentialsFilePath: string, passphrase: string);
+    save(providerId: string, credentials: ProviderCredentials): Promise<void>;
+    load(providerId: string): Promise<ProviderCredentials | null>;
+    delete(providerId: string): Promise<void>;
+    has(providerId: string): Promise<boolean>;
+    list(): Promise<string[]>;
+    /**
+     * Load and decrypt credentials file
+     */
+    private loadCredentialsFile;
+    /**
+     * Encrypt and save credentials file
+     */
+    private saveCredentialsFile;
+    /**
+     * Check if credentials file exists
+     */
+    private fileExists;
+    /**
+     * Create empty credentials file structure
+     */
+    private createEmptyCredentialsFile;
+    /**
+     * Encrypt data using AES-256-GCM
+     */
+    private encrypt;
+    /**
+     * Decrypt data using AES-256-GCM
+     */
+    private decrypt;
+}
+/**
+ * Create a credential store for a project directory
+ */
+declare function createCredentialStore(projectDir?: string, passphrase?: string): CredentialStore;
+
+/**
+ * State manager - handles project state persistence
+ */
+
+interface StateManager {
+    /**
+     * Load project state from disk
+     */
+    load(): Promise<ProjectState | null>;
+    /**
+     * Save project state to disk
+     */
+    save(state: ProjectState): Promise<void>;
+    /**
+     * Delete project state
+     */
+    delete(): Promise<void>;
+    /**
+     * Check if state exists
+     */
+    exists(): Promise<boolean>;
+}
+declare class FileStateManager implements StateManager {
+    private readonly stateFilePath;
+    constructor(stateFilePath: string);
+    load(): Promise<ProjectState | null>;
+    save(state: ProjectState): Promise<void>;
+    delete(): Promise<void>;
+    exists(): Promise<boolean>;
+}
+/**
+ * Create a state manager for a project directory
+ */
+declare function createStateManager(projectDir?: string): StateManager;
+
+/**
+ * Command orchestrator - coordinates multi-provider operations
+ */
+
+interface CommandOrchestrator {
+    /**
+     * Initialize a new project
+     */
+    initializeProject(manifest: Manifest): Promise<ProjectState>;
+    /**
+     * Provision all resources defined in manifest
+     */
+    provisionResources(manifest: Manifest): Promise<void>;
+    /**
+     * Destroy all provisioned resources
+     */
+    destroyResources(): Promise<void>;
+    /**
+     * Get current project state
+     */
+    getState(): Promise<ProjectState>;
+}
+declare class DefaultCommandOrchestrator implements CommandOrchestrator {
+    private readonly stateManager;
+    private readonly credentialStore;
+    constructor(stateManager: StateManager, credentialStore: CredentialStore);
+    initializeProject(manifest: Manifest): Promise<ProjectState>;
+    provisionResources(manifest: Manifest): Promise<void>;
+    destroyResources(): Promise<void>;
+    getState(): Promise<ProjectState>;
+}
+
+/**
+ * Deployment orchestrator - manages application deployments
+ */
+
+interface DeploymentOrchestrator {
+    /**
+     * Deploy the application
+     */
+    deploy(config: DeploymentConfig, options: DeploymentOptions): Promise<DeploymentResult>;
+    /**
+     * Get deployment status
+     */
+    getDeploymentStatus(deploymentId: string): Promise<string>;
+    /**
+     * Get deployment logs
+     */
+    getLogs(deploymentId: string, options?: LogOptions$1): Promise<string[]>;
+}
+interface LogOptions$1 {
+    tail?: number;
+    follow?: boolean;
+}
+declare class DefaultDeploymentOrchestrator implements DeploymentOrchestrator {
+    private readonly stateManager;
+    private readonly credentialStore;
+    constructor(stateManager: StateManager, credentialStore: CredentialStore);
+    deploy(config: DeploymentConfig, options: DeploymentOptions): Promise<DeploymentResult>;
+    getDeploymentStatus(deploymentId: string): Promise<string>;
+    getLogs(deploymentId: string, options?: LogOptions$1): Promise<string[]>;
+}
+
+declare class ResourceGraph {
+    private nodes;
+    addNode(id: string, dependencies?: string[]): void;
+    /**
+     * Get resources in topological order (respecting dependencies)
+     */
+    getProvisioningOrder(): string[];
+    /**
+     * Detect circular dependencies
+     */
+    hasCycle(): boolean;
+}
+
+/**
+ * Base provider interface
+ */
+
+declare abstract class BaseProvider<TConfig = unknown, TOutputs = unknown> implements Provider<TConfig, TOutputs> {
+    abstract readonly id: string;
+    abstract readonly type: ResourceType;
+    abstract readonly version: string;
+    abstract initialize(credentials: ProviderCredentials): Promise<void>;
+    abstract validate(config: TConfig): Promise<ValidationResult$1>;
+    abstract provision(config: TConfig): Promise<ProvisionResult<TOutputs>>;
+    abstract update(resourceId: string, config: TConfig): Promise<UpdateResult<TOutputs>>;
+    abstract destroy(resourceId: string): Promise<void>;
+    abstract getStatus(resourceId: string): Promise<ResourceStatus>;
+    abstract getOutputs(resourceId: string): Promise<TOutputs>;
+    abstract getEnvironmentVariables(resourceId: string): Promise<Record<string, string>>;
+}
+
+/**
+ * Provider registry - manages provider lifecycle
+ */
+
+declare class ProviderRegistry {
+    private providers;
+    /**
+     * Register a provider
+     */
+    register(provider: BaseProvider): void;
+    /**
+     * Get a provider by ID
+     */
+    get(providerId: string): BaseProvider | undefined;
+    /**
+     * Get all providers of a specific type
+     */
+    getByType(type: ResourceType): BaseProvider[];
+    /**
+     * Check if a provider is registered
+     */
+    has(providerId: string): boolean;
+    /**
+     * Get all registered provider IDs
+     */
+    list(): string[];
+    /**
+     * Dynamically load providers
+     */
+    loadProviders(providerIds: string[]): Promise<void>;
+}
+
+/**
+ * Provider factory - creates provider instances
+ */
+
+declare class ProviderFactory {
+    /**
+     * Create a provider instance
+     */
+    static create(_type: ResourceType, providerId: string, credentials: ProviderCredentials): Promise<BaseProvider>;
+}
+
+/**
+ * Database provider interface
+ */
+
+interface DatabaseProvider extends BaseProvider<DatabaseConfig, DatabaseOutputs> {
+    /**
+     * Execute a query on the database
+     */
+    executeQuery(resourceId: string, query: string): Promise<unknown>;
+    /**
+     * Create a migration
+     */
+    createMigration(resourceId: string, name: string): Promise<string>;
+}
+
+/**
+ * Cache provider interface
+ */
+
+interface CacheProvider extends BaseProvider<CacheConfig, CacheOutputs> {
+    /**
+     * Flush all cache data
+     */
+    flushCache(resourceId: string): Promise<void>;
+    /**
+     * Get cache statistics
+     */
+    getStats(resourceId: string): Promise<CacheStats>;
+}
+interface CacheStats {
+    memoryUsed: number;
+    memoryTotal: number;
+    keys: number;
+    hits: number;
+    misses: number;
+}
+
+/**
+ * Storage provider interface
+ */
+
+interface StorageProvider extends BaseProvider<StorageConfig, StorageOutputs> {
+    /**
+     * Upload a file
+     */
+    uploadFile(resourceId: string, file: Buffer, key: string): Promise<string>;
+    /**
+     * Download a file
+     */
+    downloadFile(resourceId: string, key: string): Promise<Buffer>;
+    /**
+     * Delete a file
+     */
+    deleteFile(resourceId: string, key: string): Promise<void>;
+    /**
+     * List files
+     */
+    listFiles(resourceId: string, prefix?: string): Promise<string[]>;
+}
+
+/**
+ * Email provider interface
+ */
+
+interface EmailProvider extends BaseProvider<EmailConfig, EmailOutputs> {
+    /**
+     * Send an email
+     */
+    sendEmail(resourceId: string, email: Email): Promise<void>;
+    /**
+     * Verify domain ownership
+     */
+    verifyDomain(resourceId: string): Promise<boolean>;
+    /**
+     * Get domain verification records
+     */
+    getDomainRecords(resourceId: string): Promise<DomainRecord[]>;
+}
+interface Email {
+    from: string;
+    to: string | string[];
+    subject: string;
+    text?: string;
+    html?: string;
+    cc?: string[];
+    bcc?: string[];
+}
+interface DomainRecord {
+    type: 'TXT' | 'MX' | 'CNAME';
+    name: string;
+    value: string;
+}
+
+/**
+ * Compute/deployment provider interface
+ */
+
+interface ComputeProvider extends BaseProvider<ComputeConfig, ComputeOutputs> {
+    /**
+     * Deploy an application
+     */
+    deploy(config: ComputeConfig): Promise<ComputeOutputs>;
+    /**
+     * Get deployment logs
+     */
+    getLogs(deploymentId: string, options?: LogOptions): Promise<string[]>;
+    /**
+     * Rollback to a previous version
+     */
+    rollback(deploymentId: string, version: string): Promise<void>;
+    /**
+     * Scale the deployment
+     */
+    scale(deploymentId: string, replicas: number): Promise<void>;
+}
+interface LogOptions {
+    tail?: number;
+    follow?: boolean;
+    since?: Date;
+}
+
+/**
+ * Manifest parser - loads and parses setbase.json
+ */
+
+interface ManifestParser {
+    /**
+     * Parse manifest from file path
+     */
+    parse(filePath: string): Promise<Manifest>;
+    /**
+     * Parse manifest from string
+     */
+    parseString(content: string): Promise<Manifest>;
+    /**
+     * Write manifest to file
+     */
+    write(filePath: string, manifest: Manifest): Promise<void>;
+    /**
+     * Check if manifest exists
+     */
+    exists(filePath: string): Promise<boolean>;
+}
+declare class DefaultManifestParser implements ManifestParser {
+    parse(filePath: string): Promise<Manifest>;
+    parseString(content: string): Promise<Manifest>;
+    write(filePath: string, manifest: Manifest): Promise<void>;
+    exists(filePath: string): Promise<boolean>;
+}
+/**
+ * Create a manifest parser
+ */
+declare function createManifestParser(): ManifestParser;
+/**
+ * Load manifest from project directory
+ */
+declare function loadManifest(projectDir?: string): Promise<Manifest>;
+/**
+ * Save manifest to project directory
+ */
+declare function saveManifest(manifest: Manifest, projectDir?: string): Promise<void>;
+
+/**
+ * Manifest validator - validates manifest against schema
+ */
+
+interface ManifestValidator {
+    /**
+     * Validate a manifest
+     */
+    validate(manifest: Manifest): Promise<ValidationResult>;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError$1[];
+}
+interface ValidationError$1 {
+    path: string;
+    message: string;
+}
+declare class DefaultManifestValidator implements ManifestValidator {
+    validate(manifest: Manifest): Promise<ValidationResult>;
+}
+/**
+ * Create a manifest validator
+ */
+declare function createManifestValidator(): ManifestValidator;
+/**
+ * Validate a manifest and throw if invalid
+ */
+declare function validateManifest(manifest: Manifest): Promise<void>;
+
+/**
+ * Manifest schema using Zod
+ */
+
+declare const manifestSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<"1.0">;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        runtime: z.ZodEnum<["node", "python", "go"]>;
+        framework: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        runtime: "node" | "python" | "go";
+        description?: string | undefined;
+        framework?: string | undefined;
+    }, {
+        name: string;
+        runtime: "node" | "python" | "go";
+        description?: string | undefined;
+        framework?: string | undefined;
+    }>;
+    resources: z.ZodObject<{
+        database: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        }, {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        }>>;
+        cache: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        }, {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        }>>;
+        storage: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        }, {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        }>>;
+        email: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        }, {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        database?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        cache?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        storage?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        email?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+    }, {
+        database?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        cache?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        storage?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        email?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+    }>;
+    deployment: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        config: z.ZodObject<{
+            runtime: z.ZodEnum<["node", "python", "go"]>;
+            buildCommand: z.ZodOptional<z.ZodString>;
+            startCommand: z.ZodString;
+            environmentVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            region: z.ZodOptional<z.ZodString>;
+            healthCheck: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            runtime: "node" | "python" | "go";
+            startCommand: string;
+            region?: string | undefined;
+            buildCommand?: string | undefined;
+            environmentVariables?: Record<string, string> | undefined;
+            healthCheck?: string | undefined;
+        }, {
+            runtime: "node" | "python" | "go";
+            startCommand: string;
+            region?: string | undefined;
+            buildCommand?: string | undefined;
+            environmentVariables?: Record<string, string> | undefined;
+            healthCheck?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        config: {
+            runtime: "node" | "python" | "go";
+            startCommand: string;
+            region?: string | undefined;
+            buildCommand?: string | undefined;
+            environmentVariables?: Record<string, string> | undefined;
+            healthCheck?: string | undefined;
+        };
+    }, {
+        provider: string;
+        config: {
+            runtime: "node" | "python" | "go";
+            startCommand: string;
+            region?: string | undefined;
+            buildCommand?: string | undefined;
+            environmentVariables?: Record<string, string> | undefined;
+            healthCheck?: string | undefined;
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: "1.0";
+    project: {
+        name: string;
+        runtime: "node" | "python" | "go";
+        description?: string | undefined;
+        framework?: string | undefined;
+    };
+    resources: {
+        database?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        cache?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        storage?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        email?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+    };
+    $schema?: string | undefined;
+    deployment?: {
+        provider: string;
+        config: {
+            runtime: "node" | "python" | "go";
+            startCommand: string;
+            region?: string | undefined;
+            buildCommand?: string | undefined;
+            environmentVariables?: Record<string, string> | undefined;
+            healthCheck?: string | undefined;
+        };
+    } | undefined;
+}, {
+    version: "1.0";
+    project: {
+        name: string;
+        runtime: "node" | "python" | "go";
+        description?: string | undefined;
+        framework?: string | undefined;
+    };
+    resources: {
+        database?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        cache?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        storage?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+        email?: {
+            provider: string;
+            config: Record<string, unknown>;
+            dependsOn?: string[] | undefined;
+        } | undefined;
+    };
+    $schema?: string | undefined;
+    deployment?: {
+        provider: string;
+        config: {
+            runtime: "node" | "python" | "go";
+            startCommand: string;
+            region?: string | undefined;
+            buildCommand?: string | undefined;
+            environmentVariables?: Record<string, string> | undefined;
+            healthCheck?: string | undefined;
+        };
+    } | undefined;
+}>;
+
+/**
+ * Environment aggregator - collects environment variables from all resources
+ */
+
+interface EnvironmentAggregator {
+    /**
+     * Aggregate environment variables from all provisioned resources
+     */
+    aggregate(state: ProjectState): Promise<Record<string, string>>;
+}
+declare class DefaultEnvironmentAggregator implements EnvironmentAggregator {
+    private readonly credentialStore;
+    constructor(credentialStore: CredentialStore);
+    aggregate(state: ProjectState): Promise<Record<string, string>>;
+}
+
+/**
+ * Environment manager - manages environment variables
+ */
+
+interface EnvironmentManager {
+    /**
+     * Get all environment variables for a project
+     */
+    getEnvironmentVariables(environment: string): Promise<Record<string, string>>;
+    /**
+     * Get environment variables in dotenv format
+     */
+    toDotenv(environment: string): Promise<string>;
+    /**
+     * Get environment variables in JSON format
+     */
+    toJSON(environment: string): Promise<string>;
+    /**
+     * Write environment variables to file
+     */
+    writeToFile(environment: string, filePath: string, format: 'env' | 'json'): Promise<void>;
+}
+declare class DefaultEnvironmentManager implements EnvironmentManager {
+    private readonly stateManager;
+    private readonly envAggregator;
+    constructor(stateManager: StateManager, envAggregator: EnvironmentAggregator);
+    getEnvironmentVariables(environment: string): Promise<Record<string, string>>;
+    toDotenv(environment: string): Promise<string>;
+    toJSON(environment: string): Promise<string>;
+    writeToFile(environment: string, filePath: string, format: 'env' | 'json'): Promise<void>;
+}
+
+/**
+ * Custom error classes for Setbase
+ */
+declare class SetbaseError extends Error {
+    readonly code?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code?: string | undefined, details?: unknown | undefined);
+}
+declare class ValidationError extends SetbaseError {
+    constructor(message: string, details?: unknown);
+}
+declare class ProviderError extends SetbaseError {
+    readonly provider: string;
+    constructor(message: string, provider: string, details?: unknown);
+}
+declare class StateError extends SetbaseError {
+    constructor(message: string, details?: unknown);
+}
+declare class ManifestError extends SetbaseError {
+    constructor(message: string, details?: unknown);
+}
+declare class DeploymentError extends SetbaseError {
+    constructor(message: string, details?: unknown);
+}
+
+interface Logger {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+declare const logger: Logger;
+
+/**
+ * ID generation utilities
+ */
+declare function generateId(): string;
+declare function generateProjectId(): string;
+declare function generateResourceId(): string;
+
+/**
+ * Validation utilities
+ */
+declare function validateProjectName(name: string): void;
+declare function validateResourceName(name: string): void;
+
+export { BaseProvider, CacheConfig, CacheOutputs, type CacheProvider, type CommandOrchestrator, ComputeConfig, ComputeOutputs, type ComputeProvider, type CredentialStore, DatabaseConfig, DatabaseOutputs, type DatabaseProvider, DefaultCommandOrchestrator, DefaultDeploymentOrchestrator, DefaultEnvironmentAggregator, DefaultEnvironmentManager, DefaultManifestParser, DefaultManifestValidator, DeploymentConfig, DeploymentError, DeploymentOptions, type DeploymentOrchestrator, DeploymentResult, EmailConfig, EmailOutputs, type EmailProvider, EncryptedCredentialStore, type EnvironmentAggregator, type EnvironmentManager, FileStateManager, Manifest, ManifestError, type ManifestParser, type ManifestValidator, ProjectState, Provider, ProviderCredentials, ProviderError, ProviderFactory, ProviderRegistry, ProvisionResult, ResourceGraph, ResourceStatus, ResourceType, SetbaseError, StateError, type StateManager, StorageConfig, StorageOutputs, type StorageProvider, UpdateResult, ValidationError, ValidationResult$1 as ValidationResult, createCredentialStore, createManifestParser, createManifestValidator, createStateManager, generateId, generateProjectId, generateResourceId, loadManifest, logger, manifestSchema, saveManifest, validateManifest, validateProjectName, validateResourceName };