@standards-kit/conform 0.1.0 → 0.1.3

package/dist/infra/schemas.d.ts

@@ -0,0 +1,806 @@
+/**
+ * Zod schemas for runtime validation of infra manifests and resources
+ *
+ * These schemas validate external inputs like manifest files,
+ * stack exports, ARNs, and GCP resource paths at runtime.
+ */
+import { z } from "zod";
+/**
+ * Cloud provider schema
+ */
+export declare const CloudProviderSchema: z.ZodEnum<["aws", "gcp"]>;
+export type CloudProvider = z.infer<typeof CloudProviderSchema>;
+/**
+ * Account key schema - format: "provider:accountId"
+ * Examples: "aws:123456789012", "gcp:my-project-id"
+ */
+export declare const AccountKeySchema: z.ZodString;
+export type AccountKey = z.infer<typeof AccountKeySchema>;
+/**
+ * ARN schema - validates AWS ARN format
+ *
+ * Format: arn:partition:service:region:account-id:resource
+ */
+export declare const ArnSchema: z.ZodString;
+export type Arn = z.infer<typeof ArnSchema>;
+/**
+ * Parsed ARN schema - components extracted from an ARN
+ */
+export declare const ParsedArnSchema: z.ZodObject<{
+    /** Cloud provider (always "aws" for ARNs) */
+    cloud: z.ZodLiteral<"aws">;
+    /** AWS partition (aws, aws-cn, aws-us-gov) */
+    partition: z.ZodString;
+    /** AWS service (s3, lambda, rds, etc.) */
+    service: z.ZodString;
+    /** AWS region (empty for global services like S3, IAM) */
+    region: z.ZodString;
+    /** AWS account ID (empty for S3 buckets) */
+    accountId: z.ZodString;
+    /** Resource type (e.g., function, table, bucket) */
+    resourceType: z.ZodString;
+    /** Resource name/identifier */
+    resourceId: z.ZodString;
+    /** Original ARN string */
+    raw: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    region: string;
+    cloud: "aws";
+    partition: string;
+    service: string;
+    accountId: string;
+    resourceType: string;
+    resourceId: string;
+    raw: string;
+}, {
+    region: string;
+    cloud: "aws";
+    partition: string;
+    service: string;
+    accountId: string;
+    resourceType: string;
+    resourceId: string;
+    raw: string;
+}>;
+export type ParsedArn = z.infer<typeof ParsedArnSchema>;
+/**
+ * GCP resource path schema - validates GCP resource path format
+ *
+ * Examples:
+ * - projects/my-project/locations/us-central1/functions/my-func
+ * - projects/my-project/topics/my-topic
+ * - projects/my-project/subscriptions/my-sub
+ */
+export declare const GcpResourcePathSchema: z.ZodString;
+export type GcpResourcePath = z.infer<typeof GcpResourcePathSchema>;
+/**
+ * Parsed GCP resource schema - components extracted from a GCP resource path
+ */
+export declare const ParsedGcpResourceSchema: z.ZodObject<{
+    /** Cloud provider (always "gcp" for GCP resources) */
+    cloud: z.ZodLiteral<"gcp">;
+    /** GCP project ID */
+    project: z.ZodString;
+    /** GCP service (run, iam, secretmanager, artifactregistry, etc.) */
+    service: z.ZodString;
+    /** Location/region (us-central1, global, etc.) */
+    location: z.ZodString;
+    /** Resource type (services, serviceAccounts, secrets, repositories, etc.) */
+    resourceType: z.ZodString;
+    /** Resource name/ID */
+    resourceId: z.ZodString;
+    /** Original resource path */
+    raw: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    cloud: "gcp";
+    service: string;
+    resourceType: string;
+    resourceId: string;
+    raw: string;
+    location: string;
+}, {
+    project: string;
+    cloud: "gcp";
+    service: string;
+    resourceType: string;
+    resourceId: string;
+    raw: string;
+    location: string;
+}>;
+export type ParsedGcpResource = z.infer<typeof ParsedGcpResourceSchema>;
+/**
+ * Generic resource identifier - can be AWS ARN or GCP resource path
+ */
+export declare const ResourceIdentifierSchema: z.ZodUnion<[z.ZodString, z.ZodString]>;
+export type ResourceIdentifier = z.infer<typeof ResourceIdentifierSchema>;
+/**
+ * Account identifier schema - parsed from account key
+ */
+export declare const AccountIdSchema: z.ZodObject<{
+    /** Cloud provider */
+    cloud: z.ZodEnum<["aws", "gcp"]>;
+    /** AWS account ID or GCP project ID */
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    cloud: "aws" | "gcp";
+}, {
+    id: string;
+    cloud: "aws" | "gcp";
+}>;
+export type AccountId = z.infer<typeof AccountIdSchema>;
+/**
+ * Account entry in a multi-account manifest
+ */
+export declare const ManifestAccountSchema: z.ZodObject<{
+    /** Optional human-readable alias for this account */
+    alias: z.ZodOptional<z.ZodString>;
+    /** List of resource identifiers (ARNs or GCP resource paths) */
+    resources: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    resources: string[];
+    alias?: string | undefined;
+}, {
+    resources: string[];
+    alias?: string | undefined;
+}>;
+export type ManifestAccount = z.infer<typeof ManifestAccountSchema>;
+/**
+ * V2 Multi-account manifest schema
+ *
+ * Resources are grouped by cloud account (AWS account ID or GCP project ID)
+ */
+export declare const MultiAccountManifestSchema: z.ZodObject<{
+    /** Manifest version - must be 2 for multi-account format */
+    version: z.ZodLiteral<2>;
+    /** Optional project name */
+    project: z.ZodOptional<z.ZodString>;
+    /** Resources grouped by account key (e.g., "aws:123456789012", "gcp:my-project") */
+    accounts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        /** Optional human-readable alias for this account */
+        alias: z.ZodOptional<z.ZodString>;
+        /** List of resource identifiers (ARNs or GCP resource paths) */
+        resources: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        resources: string[];
+        alias?: string | undefined;
+    }, {
+        resources: string[];
+        alias?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: 2;
+    accounts: Record<string, {
+        resources: string[];
+        alias?: string | undefined;
+    }>;
+    project?: string | undefined;
+}, {
+    version: 2;
+    accounts: Record<string, {
+        resources: string[];
+        alias?: string | undefined;
+    }>;
+    project?: string | undefined;
+}>;
+export type MultiAccountManifest = z.infer<typeof MultiAccountManifestSchema>;
+/**
+ * Legacy manifest schema (v1) - flat array of resources
+ */
+export declare const LegacyManifestSchema: z.ZodObject<{
+    /** Optional manifest version (1 or undefined for legacy) */
+    version: z.ZodOptional<z.ZodLiteral<1>>;
+    /** Optional project name */
+    project: z.ZodOptional<z.ZodString>;
+    /** Flat list of resource identifiers */
+    resources: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    resources: string[];
+    version?: 1 | undefined;
+    project?: string | undefined;
+}, {
+    resources: string[];
+    version?: 1 | undefined;
+    project?: string | undefined;
+}>;
+export type LegacyManifest = z.infer<typeof LegacyManifestSchema>;
+/**
+ * Any manifest schema - accepts either v1 or v2 format
+ */
+export declare const ManifestSchema: z.ZodUnion<[z.ZodObject<{
+    /** Manifest version - must be 2 for multi-account format */
+    version: z.ZodLiteral<2>;
+    /** Optional project name */
+    project: z.ZodOptional<z.ZodString>;
+    /** Resources grouped by account key (e.g., "aws:123456789012", "gcp:my-project") */
+    accounts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        /** Optional human-readable alias for this account */
+        alias: z.ZodOptional<z.ZodString>;
+        /** List of resource identifiers (ARNs or GCP resource paths) */
+        resources: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        resources: string[];
+        alias?: string | undefined;
+    }, {
+        resources: string[];
+        alias?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: 2;
+    accounts: Record<string, {
+        resources: string[];
+        alias?: string | undefined;
+    }>;
+    project?: string | undefined;
+}, {
+    version: 2;
+    accounts: Record<string, {
+        resources: string[];
+        alias?: string | undefined;
+    }>;
+    project?: string | undefined;
+}>, z.ZodObject<{
+    /** Optional manifest version (1 or undefined for legacy) */
+    version: z.ZodOptional<z.ZodLiteral<1>>;
+    /** Optional project name */
+    project: z.ZodOptional<z.ZodString>;
+    /** Flat list of resource identifiers */
+    resources: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    resources: string[];
+    version?: 1 | undefined;
+    project?: string | undefined;
+}, {
+    resources: string[];
+    version?: 1 | undefined;
+    project?: string | undefined;
+}>]>;
+export type Manifest = z.infer<typeof ManifestSchema>;
+/**
+ * Result of checking a single resource
+ */
+export declare const ResourceCheckResultSchema: z.ZodObject<{
+    /** The resource ARN or GCP path */
+    arn: z.ZodString;
+    /** Whether the resource exists */
+    exists: z.ZodBoolean;
+    /** Error message if check failed */
+    error: z.ZodOptional<z.ZodString>;
+    /** Service name (e.g., s3, lambda, run) */
+    service: z.ZodString;
+    /** Resource type (e.g., bucket, function) */
+    resourceType: z.ZodString;
+    /** Resource identifier */
+    resourceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    exists: boolean;
+    service: string;
+    resourceType: string;
+    resourceId: string;
+    arn: string;
+    error?: string | undefined;
+}, {
+    exists: boolean;
+    service: string;
+    resourceType: string;
+    resourceId: string;
+    arn: string;
+    error?: string | undefined;
+}>;
+export type ResourceCheckResult = z.infer<typeof ResourceCheckResultSchema>;
+/**
+ * Scan summary statistics
+ */
+export declare const InfraScanSummarySchema: z.ZodObject<{
+    /** Total resources checked */
+    total: z.ZodNumber;
+    /** Resources that exist */
+    found: z.ZodNumber;
+    /** Resources that don't exist */
+    missing: z.ZodNumber;
+    /** Resources that couldn't be checked (errors) */
+    errors: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    missing: number;
+    found: number;
+    errors: number;
+}, {
+    total: number;
+    missing: number;
+    found: number;
+    errors: number;
+}>;
+export type InfraScanSummary = z.infer<typeof InfraScanSummarySchema>;
+/**
+ * Per-account scan results
+ */
+declare const AccountScanResultSchema: z.ZodObject<{
+    /** Account alias if provided */
+    alias: z.ZodOptional<z.ZodString>;
+    /** Individual resource check results */
+    results: z.ZodArray<z.ZodObject<{
+        /** The resource ARN or GCP path */
+        arn: z.ZodString;
+        /** Whether the resource exists */
+        exists: z.ZodBoolean;
+        /** Error message if check failed */
+        error: z.ZodOptional<z.ZodString>;
+        /** Service name (e.g., s3, lambda, run) */
+        service: z.ZodString;
+        /** Resource type (e.g., bucket, function) */
+        resourceType: z.ZodString;
+        /** Resource identifier */
+        resourceId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        exists: boolean;
+        service: string;
+        resourceType: string;
+        resourceId: string;
+        arn: string;
+        error?: string | undefined;
+    }, {
+        exists: boolean;
+        service: string;
+        resourceType: string;
+        resourceId: string;
+        arn: string;
+        error?: string | undefined;
+    }>, "many">;
+    /** Summary statistics for this account */
+    summary: z.ZodObject<{
+        /** Total resources checked */
+        total: z.ZodNumber;
+        /** Resources that exist */
+        found: z.ZodNumber;
+        /** Resources that don't exist */
+        missing: z.ZodNumber;
+        /** Resources that couldn't be checked (errors) */
+        errors: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        missing: number;
+        found: number;
+        errors: number;
+    }, {
+        total: number;
+        missing: number;
+        found: number;
+        errors: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    summary: {
+        total: number;
+        missing: number;
+        found: number;
+        errors: number;
+    };
+    results: {
+        exists: boolean;
+        service: string;
+        resourceType: string;
+        resourceId: string;
+        arn: string;
+        error?: string | undefined;
+    }[];
+    alias?: string | undefined;
+}, {
+    summary: {
+        total: number;
+        missing: number;
+        found: number;
+        errors: number;
+    };
+    results: {
+        exists: boolean;
+        service: string;
+        resourceType: string;
+        resourceId: string;
+        arn: string;
+        error?: string | undefined;
+    }[];
+    alias?: string | undefined;
+}>;
+export type AccountScanResult = z.infer<typeof AccountScanResultSchema>;
+/**
+ * Full infrastructure scan result
+ */
+export declare const InfraScanResultSchema: z.ZodObject<{
+    /** Path to the manifest file */
+    manifest: z.ZodString;
+    /** Project name */
+    project: z.ZodOptional<z.ZodString>;
+    /** Individual resource check results */
+    results: z.ZodArray<z.ZodObject<{
+        /** The resource ARN or GCP path */
+        arn: z.ZodString;
+        /** Whether the resource exists */
+        exists: z.ZodBoolean;
+        /** Error message if check failed */
+        error: z.ZodOptional<z.ZodString>;
+        /** Service name (e.g., s3, lambda, run) */
+        service: z.ZodString;
+        /** Resource type (e.g., bucket, function) */
+        resourceType: z.ZodString;
+        /** Resource identifier */
+        resourceId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        exists: boolean;
+        service: string;
+        resourceType: string;
+        resourceId: string;
+        arn: string;
+        error?: string | undefined;
+    }, {
+        exists: boolean;
+        service: string;
+        resourceType: string;
+        resourceId: string;
+        arn: string;
+        error?: string | undefined;
+    }>, "many">;
+    /** Summary statistics */
+    summary: z.ZodObject<{
+        /** Total resources checked */
+        total: z.ZodNumber;
+        /** Resources that exist */
+        found: z.ZodNumber;
+        /** Resources that don't exist */
+        missing: z.ZodNumber;
+        /** Resources that couldn't be checked (errors) */
+        errors: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        missing: number;
+        found: number;
+        errors: number;
+    }, {
+        total: number;
+        missing: number;
+        found: number;
+        errors: number;
+    }>;
+    /** Per-account results (only present for multi-account manifests) */
+    accountResults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        /** Account alias if provided */
+        alias: z.ZodOptional<z.ZodString>;
+        /** Individual resource check results */
+        results: z.ZodArray<z.ZodObject<{
+            /** The resource ARN or GCP path */
+            arn: z.ZodString;
+            /** Whether the resource exists */
+            exists: z.ZodBoolean;
+            /** Error message if check failed */
+            error: z.ZodOptional<z.ZodString>;
+            /** Service name (e.g., s3, lambda, run) */
+            service: z.ZodString;
+            /** Resource type (e.g., bucket, function) */
+            resourceType: z.ZodString;
+            /** Resource identifier */
+            resourceId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            exists: boolean;
+            service: string;
+            resourceType: string;
+            resourceId: string;
+            arn: string;
+            error?: string | undefined;
+        }, {
+            exists: boolean;
+            service: string;
+            resourceType: string;
+            resourceId: string;
+            arn: string;
+            error?: string | undefined;
+        }>, "many">;
+        /** Summary statistics for this account */
+        summary: z.ZodObject<{
+            /** Total resources checked */
+            total: z.ZodNumber;
+            /** Resources that exist */
+            found: z.ZodNumber;
+            /** Resources that don't exist */
+            missing: z.ZodNumber;
+            /** Resources that couldn't be checked (errors) */
+            errors: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            total: number;
+            missing: number;
+            found: number;
+            errors: number;
+        }, {
+            total: number;
+            missing: number;
+            found: number;
+            errors: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        summary: {
+            total: number;
+            missing: number;
+            found: number;
+            errors: number;
+        };
+        results: {
+            exists: boolean;
+            service: string;
+            resourceType: string;
+            resourceId: string;
+            arn: string;
+            error?: string | undefined;
+        }[];
+        alias?: string | undefined;
+    }, {
+        summary: {
+            total: number;
+            missing: number;
+            found: number;
+            errors: number;
+        };
+        results: {
+            exists: boolean;
+            service: string;
+            resourceType: string;
+            resourceId: string;
+            arn: string;
+            error?: string | undefined;
+        }[];
+        alias?: string | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    manifest: string;
+    summary: {
+        total: number;
+        missing: number;
+        found: number;
+        errors: number;
+    };
+    results: {
+        exists: boolean;
+        service: string;
+        resourceType: string;
+        resourceId: string;
+        arn: string;
+        error?: string | undefined;
+    }[];
+    project?: string | undefined;
+    accountResults?: Record<string, {
+        summary: {
+            total: number;
+            missing: number;
+            found: number;
+            errors: number;
+        };
+        results: {
+            exists: boolean;
+            service: string;
+            resourceType: string;
+            resourceId: string;
+            arn: string;
+            error?: string | undefined;
+        }[];
+        alias?: string | undefined;
+    }> | undefined;
+}, {
+    manifest: string;
+    summary: {
+        total: number;
+        missing: number;
+        found: number;
+        errors: number;
+    };
+    results: {
+        exists: boolean;
+        service: string;
+        resourceType: string;
+        resourceId: string;
+        arn: string;
+        error?: string | undefined;
+    }[];
+    project?: string | undefined;
+    accountResults?: Record<string, {
+        summary: {
+            total: number;
+            missing: number;
+            found: number;
+            errors: number;
+        };
+        results: {
+            exists: boolean;
+            service: string;
+            resourceType: string;
+            resourceId: string;
+            arn: string;
+            error?: string | undefined;
+        }[];
+        alias?: string | undefined;
+    }> | undefined;
+}>;
+export type InfraScanResult = z.infer<typeof InfraScanResultSchema>;
+/**
+ * Options for programmatic API
+ */
+export interface ScanInfraOptions {
+    /** Path to manifest file */
+    manifestPath?: string;
+    /** Path to config file */
+    configPath?: string;
+    /** Filter to specific account (by alias or account key like "aws:123") */
+    account?: string;
+}
+/**
+ * Options for CLI handler
+ */
+export type RunInfraScanOptions = ScanInfraOptions & {
+    /** Output format */
+    format?: "text" | "json";
+};
+/**
+ * Pulumi resource in stack export
+ */
+export declare const PulumiResourceSchema: z.ZodObject<{
+    urn: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type?: string | undefined;
+    urn?: string | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    outputs?: Record<string, unknown> | undefined;
+}, {
+    type?: string | undefined;
+    urn?: string | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    outputs?: Record<string, unknown> | undefined;
+}>;
+export type PulumiResource = z.infer<typeof PulumiResourceSchema>;
+/**
+ * Pulumi stack export schema (simplified)
+ */
+export declare const PulumiStackExportSchema: z.ZodObject<{
+    version: z.ZodOptional<z.ZodNumber>;
+    deployment: z.ZodOptional<z.ZodObject<{
+        manifest: z.ZodOptional<z.ZodObject<{
+            time: z.ZodOptional<z.ZodString>;
+            magic: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            time?: string | undefined;
+            version?: string | undefined;
+            magic?: string | undefined;
+        }, {
+            time?: string | undefined;
+            version?: string | undefined;
+            magic?: string | undefined;
+        }>>;
+        resources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            urn: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: string | undefined;
+            urn?: string | undefined;
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }, {
+            type?: string | undefined;
+            urn?: string | undefined;
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        manifest?: {
+            time?: string | undefined;
+            version?: string | undefined;
+            magic?: string | undefined;
+        } | undefined;
+        resources?: {
+            type?: string | undefined;
+            urn?: string | undefined;
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }, {
+        manifest?: {
+            time?: string | undefined;
+            version?: string | undefined;
+            magic?: string | undefined;
+        } | undefined;
+        resources?: {
+            type?: string | undefined;
+            urn?: string | undefined;
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version?: number | undefined;
+    deployment?: {
+        manifest?: {
+            time?: string | undefined;
+            version?: string | undefined;
+            magic?: string | undefined;
+        } | undefined;
+        resources?: {
+            type?: string | undefined;
+            urn?: string | undefined;
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    } | undefined;
+}, {
+    version?: number | undefined;
+    deployment?: {
+        manifest?: {
+            time?: string | undefined;
+            version?: string | undefined;
+            magic?: string | undefined;
+        } | undefined;
+        resources?: {
+            type?: string | undefined;
+            urn?: string | undefined;
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    } | undefined;
+}>;
+export type PulumiStackExport = z.infer<typeof PulumiStackExportSchema>;
+/**
+ * Validate an ARN string
+ * @throws ZodError if invalid
+ */
+export declare function validateArn(arn: string): Arn;
+/**
+ * Check if a string is a valid ARN format
+ */
+export declare function isValidArnFormat(arn: string): boolean;
+/**
+ * Validate a GCP resource path
+ * @throws ZodError if invalid
+ */
+export declare function validateGcpResourcePath(path: string): GcpResourcePath;
+/**
+ * Check if a string is a valid GCP resource path
+ */
+export declare function isValidGcpResourcePath(path: string): boolean;
+/**
+ * Validate an account key string
+ * @throws ZodError if invalid
+ */
+export declare function validateAccountKey(key: string): AccountKey;
+/**
+ * Check if a string is a valid account key
+ */
+export declare function isValidAccountKey(key: string): boolean;
+/**
+ * Validate a legacy (v1) manifest
+ * @throws ZodError if invalid
+ */
+export declare function validateLegacyManifest(data: unknown): LegacyManifest;
+/**
+ * Validate a multi-account (v2) manifest
+ * @throws ZodError if invalid
+ */
+export declare function validateMultiAccountManifest(data: unknown): MultiAccountManifest;
+/**
+ * Validate any manifest format (v1 or v2)
+ * @throws ZodError if invalid
+ */
+export declare function validateManifest(data: unknown): Manifest;
+/**
+ * Check if data is a valid multi-account (v2) manifest
+ */
+export declare function isMultiAccountManifestSchema(data: unknown): data is MultiAccountManifest;
+/**
+ * Check if data is a valid legacy (v1) manifest
+ */
+export declare function isLegacyManifestSchema(data: unknown): data is LegacyManifest;
+/**
+ * Validate a Pulumi stack export
+ * @throws ZodError if invalid
+ */
+export declare function validateStackExport(data: unknown): PulumiStackExport;
+export {};