import { z } from 'zod';
import { C as CorsConfig, a as CorsConfigSchema, H as HttpMethod, b as HttpMethodSchema, c as HttpMethodType, d as HttpRequest, e as HttpRequestSchema, R as RateLimitConfig, f as RateLimitConfigSchema, S as StaticMount, g as StaticMountSchema } from './http.zod-D7ZTstT3.js';

/**
 * System Identifier Schema
 *
 * Universal naming convention for all machine identifiers (API Names) in ObjectStack.
 * Enforces lowercase with underscores or dots to ensure:
 * - Cross-platform compatibility (case-insensitive filesystems)
 * - URL-friendliness (no encoding needed)
 * - Database consistency (no collation issues)
 * - Security (no case-sensitivity bugs in permission checks)
 *
 * **Applies to all metadata that acts as a machine identifier:**
 * - Object names (tables/collections)
 * - Field names
 * - Role names
 * - Permission set names
 * - Action/trigger names
 * - Event keys
 * - App IDs
 * - Menu/page IDs
 * - Select option values
 * - Workflow names
 * - Webhook names
 *
 * **Naming Convention Summary:**
 * | Type | Pattern | Example |
 * |------|---------|---------|
 * | Machine ID | snake_case | `crm_account`, `btn_submit`, `role_admin` |
 * | Event keys | dot.notation | `user.login`, `order.created` |
 * | Labels | Any case | `Client Account`, `Submit Form` |
 *
 * @example Valid identifiers
 * - 'account'
 * - 'crm_account'
 * - 'user_profile'
 * - 'order.created' (for events)
 * - 'api_v2_endpoint'
 *
 * @example Invalid identifiers (will be rejected)
 * - 'Account' (uppercase)
 * - 'CrmAccount' (camelCase)
 * - 'crm-account' (kebab-case - use underscore instead)
 * - 'user profile' (spaces)
 */
declare const SystemIdentifierSchema: z.ZodString;
/**
 * Strict Snake Case Identifier
 *
 * More restrictive than SystemIdentifierSchema - only allows underscores (no dots).
 * Use this for identifiers that should NOT contain dots (e.g., database table/column names).
 *
 * @example Valid
 * - 'account'
 * - 'crm_account'
 * - 'user_profile'
 *
 * @example Invalid
 * - 'user.profile' (dots not allowed)
 * - 'UserProfile' (uppercase)
 */
declare const SnakeCaseIdentifierSchema: z.ZodString;
/**
 * Event Name Identifier
 *
 * Specialized identifier for event names that encourages dot notation.
 * Used in event-driven systems, message queues, and webhooks.
 *
 * Pattern: `namespace.action` or `entity.event_type`
 *
 * @example Valid
 * - 'user.created'
 * - 'order.paid'
 * - 'user.login_success'
 * - 'alarm.high_cpu'
 *
 * @example Invalid
 * - 'UserCreated' (camelCase)
 * - 'user_created' (should use dots for namespacing)
 */
declare const EventNameSchema: z.ZodString;
/**
 * Type Exports
 */
type SystemIdentifier = z.infer<typeof SystemIdentifierSchema>;
type SnakeCaseIdentifier = z.infer<typeof SnakeCaseIdentifierSchema>;
type EventName = z.infer<typeof EventNameSchema>;

/**
 * Base Field Mapping Protocol
 *
 * Shared by: ETL, Sync, Connector, External Lookup
 *
 * This module provides the canonical field mapping schema used across
 * ObjectStack for data transformation and synchronization.
 *
 * **Use Cases:**
 * - ETL pipelines (data/mapping.zod.ts)
 * - Data synchronization (automation/sync.zod.ts)
 * - Integration connectors (integration/connector.zod.ts)
 * - External lookups (data/external-lookup.zod.ts)
 *
 * @example Basic field mapping
 * ```typescript
 * const mapping: FieldMapping = {
 *   source: 'external_user_id',
 *   target: 'user_id',
 * };
 * ```
 *
 * @example With transformation
 * ```typescript
 * const mapping: FieldMapping = {
 *   source: 'user_name',
 *   target: 'name',
 *   transform: { type: 'cast', targetType: 'string' },
 *   defaultValue: 'Unknown'
 * };
 * ```
 */
/**
 * Transform Type Schema
 *
 * Defines the type of transformation to apply to a field value.
 * Implementations can extend this for domain-specific transforms.
 */
declare const TransformTypeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    type: z.ZodLiteral<"constant">;
    value: z.ZodUnknown;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<"cast">;
    targetType: z.ZodEnum<{
        string: "string";
        number: "number";
        boolean: "boolean";
        date: "date";
    }>;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<"lookup">;
    table: z.ZodString;
    keyField: z.ZodString;
    valueField: z.ZodString;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<"javascript">;
    expression: z.ZodString;
}, z.core.$strip>, z.ZodObject<{
    type: z.ZodLiteral<"map">;
    mappings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, z.core.$strip>], "type">;
type TransformType = z.infer<typeof TransformTypeSchema>;
/**
 * Field Mapping Schema
 *
 * Base schema for mapping fields between source and target systems.
 *
 * **NAMING CONVENTION:**
 * - source: Field name in the source system
 * - target: Field name in the target system (should be snake_case for ObjectStack)
 *
 * @example
 * ```typescript
 * {
 *   source: 'FirstName',
 *   target: 'first_name',
 *   transform: { type: 'cast', targetType: 'string' },
 *   defaultValue: ''
 * }
 * ```
 */
declare const FieldMappingSchema: z.ZodObject<{
    source: z.ZodString;
    target: z.ZodString;
    transform: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
        type: z.ZodLiteral<"constant">;
        value: z.ZodUnknown;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"cast">;
        targetType: z.ZodEnum<{
            string: "string";
            number: "number";
            boolean: "boolean";
            date: "date";
        }>;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"lookup">;
        table: z.ZodString;
        keyField: z.ZodString;
        valueField: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"javascript">;
        expression: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        type: z.ZodLiteral<"map">;
        mappings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, z.core.$strip>], "type">>;
    defaultValue: z.ZodOptional<z.ZodUnknown>;
}, z.core.$strip>;
type FieldMapping = z.infer<typeof FieldMappingSchema>;

/** Aggregation functions used across query, data-engine, analytics, field */
declare const AggregationFunctionEnum: z.ZodEnum<{
    count: "count";
    sum: "sum";
    avg: "avg";
    min: "min";
    max: "max";
    count_distinct: "count_distinct";
    percentile: "percentile";
    median: "median";
    stddev: "stddev";
    variance: "variance";
}>;
type AggregationFunction = z.infer<typeof AggregationFunctionEnum>;
/** Sort direction used across query, data-engine, analytics */
declare const SortDirectionEnum: z.ZodEnum<{
    asc: "asc";
    desc: "desc";
}>;
type SortDirection = z.infer<typeof SortDirectionEnum>;
/** Reusable sort item — field + direction pair used across views, data sources, filters */
declare const SortItemSchema: z.ZodObject<{
    field: z.ZodString;
    order: z.ZodEnum<{
        asc: "asc";
        desc: "desc";
    }>;
}, z.core.$strip>;
type SortItem = z.infer<typeof SortItemSchema>;
/** CRUD mutation events used across hook, validation, object CDC */
declare const MutationEventEnum: z.ZodEnum<{
    insert: "insert";
    update: "update";
    delete: "delete";
    upsert: "upsert";
}>;
type MutationEvent = z.infer<typeof MutationEventEnum>;
/** Database isolation levels — unified format */
declare const IsolationLevelEnum: z.ZodEnum<{
    read_uncommitted: "read_uncommitted";
    read_committed: "read_committed";
    repeatable_read: "repeatable_read";
    serializable: "serializable";
    snapshot: "snapshot";
}>;
type IsolationLevel = z.infer<typeof IsolationLevelEnum>;
/** Cache eviction strategies */
declare const CacheStrategyEnum: z.ZodEnum<{
    lru: "lru";
    lfu: "lfu";
    ttl: "ttl";
    fifo: "fifo";
}>;
type CacheStrategy = z.infer<typeof CacheStrategyEnum>;

/** Supported metadata file formats */
declare const MetadataFormatSchema: z.ZodEnum<{
    javascript: "javascript";
    yaml: "yaml";
    json: "json";
    typescript: "typescript";
}>;
type MetadataFormat = z.infer<typeof MetadataFormatSchema>;
/** Base metadata record fields shared across kernel and system layers */
declare const BaseMetadataRecordSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodString;
    name: z.ZodString;
    format: z.ZodOptional<z.ZodEnum<{
        javascript: "javascript";
        yaml: "yaml";
        json: "json";
        typescript: "typescript";
    }>>;
}, z.core.$strip>;
type BaseMetadataRecord = z.infer<typeof BaseMetadataRecordSchema>;

/**
 * Branded Types for ObjectStack Identifiers
 *
 * Branded types provide compile-time safety by preventing accidental mixing
 * of different identifier kinds. For example, you cannot pass an ObjectName
 * where a FieldName is expected, even though both are strings at runtime.
 *
 * @example
 * ```ts
 * import { ObjectNameSchema, FieldNameSchema } from '@objectstack/spec';
 *
 * const objName = ObjectNameSchema.parse('project_task');   // ObjectName
 * const fieldName = FieldNameSchema.parse('task_name');     // FieldName
 *
 * // TypeScript will catch this at compile time:
 * // const fn: FieldName = objName; // Error!
 * ```
 */
/**
 * ObjectName — Branded type for business object names.
 *
 * Must be snake_case (no dots). Used for table/collection names.
 *
 * @example 'project_task', 'crm_account', 'user_profile'
 */
declare const ObjectNameSchema: z.core.$ZodBranded<z.ZodString, "ObjectName", "out">;
type ObjectName = z.infer<typeof ObjectNameSchema>;
/**
 * FieldName — Branded type for field (column) names.
 *
 * Must be snake_case (no dots). Used for column/property names within objects.
 *
 * @example 'first_name', 'created_at', 'total_amount'
 */
declare const FieldNameSchema: z.core.$ZodBranded<z.ZodString, "FieldName", "out">;
type FieldName = z.infer<typeof FieldNameSchema>;
/**
 * ViewName — Branded type for view identifiers.
 *
 * Must be a valid system identifier (lowercase, may contain dots for namespacing).
 *
 * @example 'all_tasks', 'my_open_deals', 'contact.recent'
 */
declare const ViewNameSchema: z.core.$ZodBranded<z.ZodString, "ViewName", "out">;
type ViewName = z.infer<typeof ViewNameSchema>;
/**
 * AppName — Branded type for application identifiers.
 *
 * Must be a valid system identifier.
 *
 * @example 'crm', 'helpdesk', 'project_management'
 */
declare const AppNameSchema: z.core.$ZodBranded<z.ZodString, "AppName", "out">;
type AppName = z.infer<typeof AppNameSchema>;
/**
 * FlowName — Branded type for flow identifiers.
 *
 * Must be a valid system identifier.
 *
 * @example 'approval_flow', 'onboarding_wizard', 'lead_qualification'
 */
declare const FlowNameSchema: z.core.$ZodBranded<z.ZodString, "FlowName", "out">;
type FlowName = z.infer<typeof FlowNameSchema>;
/**
 * RoleName — Branded type for role identifiers.
 *
 * Must be a valid system identifier.
 *
 * @example 'admin', 'sales_manager', 'read_only'
 */
declare const RoleNameSchema: z.core.$ZodBranded<z.ZodString, "RoleName", "out">;
type RoleName = z.infer<typeof RoleNameSchema>;

/**
 * "Did you mean?" Suggestion Utilities
 *
 * Provides fuzzy matching for common ObjectStack identifiers.
 * Used by the custom error map to suggest corrections for typos.
 *
 * @example
 * ```ts
 * suggestFieldType('text_area');  // ['textarea']
 * suggestFieldType('String');     // ['text']
 * suggestFieldType('int');        // ['number']
 * ```
 */
/**
 * Compute Levenshtein edit distance between two strings.
 * Uses space-optimized two-row approach (O(min(m,n)) space).
 */
declare function levenshteinDistance(a: string, b: string): number;
/**
 * Find the closest matches from a list of candidates.
 *
 * @param input - The user-provided (possibly invalid) value
 * @param candidates - Array of valid values to compare against
 * @param maxDistance - Maximum edit distance to consider (default: 3)
 * @param maxResults - Maximum number of suggestions to return (default: 3)
 * @returns Array of suggested values, sorted by similarity
 */
declare function findClosestMatches(input: string, candidates: readonly string[], maxDistance?: number, maxResults?: number): string[];
/**
 * Suggest valid FieldType values for an invalid input.
 *
 * First checks known aliases, then falls back to fuzzy matching.
 *
 * @param input - Invalid field type string
 * @returns Array of suggested valid FieldType values
 *
 * @example
 * ```ts
 * suggestFieldType('text_area');  // ['textarea']
 * suggestFieldType('String');     // ['text']
 * suggestFieldType('int');        // ['number']
 * suggestFieldType('dropdown');   // ['select']
 * ```
 */
declare function suggestFieldType(input: string): string[];
/**
 * Format a "Did you mean?" message for display.
 *
 * @param suggestions - Array of suggested values
 * @returns Formatted string or empty string if no suggestions
 */
declare function formatSuggestion(suggestions: string[]): string;

/**
 * Zod v4 raw issue type used by the error map.
 */
type ObjectStackRawIssue = z.core.$ZodRawIssue;
/**
 * ObjectStack Custom Zod Error Map
 *
 * Provides contextual, actionable error messages for ObjectStack schema validation.
 * Instead of generic Zod messages like "Invalid option", this error map returns
 * messages that explain the ObjectStack context and suggest fixes.
 *
 * In Zod v4, the error map is a function `(issue) => { message: string } | string | null`.
 * Pass it via the `error` option on `.safeParse()` / `.parse()`.
 *
 * @example
 * ```ts
 * import { objectStackErrorMap } from '@objectstack/spec';
 *
 * // Per-parse usage
 * SomeSchema.safeParse(data, { error: objectStackErrorMap });
 * ```
 */
declare const objectStackErrorMap: (issue: ObjectStackRawIssue) => {
    message: string;
} | null;
/**
 * Zod Issue interface (subset needed for formatting).
 */
interface ZodIssueMinimal {
    path: PropertyKey[];
    message: string;
    code?: string;
}
/**
 * Format a single Zod issue into a human-readable line.
 *
 * @param issue - A single Zod issue
 * @returns Formatted string with path and message
 */
declare function formatZodIssue(issue: ZodIssueMinimal): string;
/**
 * Pretty-print Zod validation errors for CLI output.
 *
 * Formats a ZodError into a readable block suitable for terminal display.
 * Groups errors by path depth and includes a summary count.
 *
 * @param error - A ZodError to format
 * @param label - Optional label for the error block (e.g., 'Stack validation failed')
 * @returns Formatted multi-line string
 *
 * @example
 * ```ts
 * import { formatZodError, ObjectStackDefinitionSchema } from '@objectstack/spec';
 *
 * const result = ObjectStackDefinitionSchema.safeParse(data);
 * if (!result.success) {
 *   console.error(formatZodError(result.error, 'Stack validation failed'));
 * }
 * ```
 *
 * Output:
 * ```
 * Stack validation failed (3 issues):
 *
 *   ✗ manifest.name: Required property 'name' is missing.
 *   ✗ objects[0].fields.status.type: Invalid field type 'dropdown'. Did you mean 'select'?
 *   ✗ views[0].object: Invalid identifier 'MyTasks'. Must be lowercase snake_case.
 * ```
 */
declare function formatZodError(error: z.ZodError, label?: string): string;
/**
 * Parse with the ObjectStack error map and return formatted errors.
 *
 * A convenience function that combines parsing with the custom error map
 * and pretty-print formatting. Returns a discriminated union result.
 *
 * @param schema - Any Zod schema to parse with
 * @param data - Data to validate
 * @param label - Optional label for error formatting
 * @returns Object with `success`, `data`, and optional `formatted` error string
 *
 * @example
 * ```ts
 * const result = safeParsePretty(ObjectStackDefinitionSchema, config, 'objectstack.config.ts');
 * if (!result.success) {
 *   console.error(result.formatted);
 *   process.exit(1);
 * }
 * ```
 */
declare function safeParsePretty<T extends z.ZodTypeAny>(schema: T, data: unknown, label?: string): {
    success: true;
    data: z.infer<T>;
} | {
    success: false;
    error: z.ZodError;
    formatted: string;
};

/**
 * Metadata Collection Utilities
 *
 * Provides support for defining metadata collections in either array or map (Record) format.
 * Map format automatically injects the key as the `name` field, following the same pattern
 * used by `fields` in ObjectSchema (which already uses `z.record(key, FieldSchema)`).
 *
 * ## Usage
 *
 * Both formats are accepted and normalized to arrays:
 *
 * ```ts
 * // Array format (traditional)
 * defineStack({
 *   objects: [
 *     { name: 'account', fields: { ... } },
 *     { name: 'contact', fields: { ... } },
 *   ]
 * });
 *
 * // Map format (key becomes `name`)
 * defineStack({
 *   objects: {
 *     account: { fields: { ... } },
 *     contact: { fields: { ... } },
 *   }
 * });
 * ```
 *
 * @module
 */
/**
 * Input type for metadata collections: accepts either an array or a named map.
 * When using map format, the key is injected as the `name` field of each item.
 *
 * @typeParam T - The metadata item type (e.g., `ObjectSchema`, `AppSchema`)
 *
 * @example
 * ```ts
 * // Array format — name is required in each item
 * const apps: MetadataCollectionInput<App> = [
 *   { name: 'sales', label: 'Sales' },
 *   { name: 'service', label: 'Service' },
 * ];
 *
 * // Map format — key serves as name, so name is optional in value
 * const apps: MetadataCollectionInput<App> = {
 *   sales: { label: 'Sales' },
 *   service: { label: 'Service' },
 * };
 * ```
 */
type MetadataCollectionInput<T> = T[] | Record<string, Omit<T, 'name'> & {
    name?: string;
}>;
/**
 * List of metadata fields in ObjectStackDefinitionSchema that support map format.
 * These are fields where each item has a `name` field that can be inferred from the map key.
 *
 * Excluded fields:
 * - `views` — ViewSchema has no `name` field (it's a container with `list`/`form`)
 * - `objectExtensions` — uses `extend` as its identifier, not `name`
 * - `data` — DatasetSchema uses `object` as its identifier
 * - `translations` — TranslationBundleSchema is a record, not a named object
 * - `plugins` / `devPlugins` — not named metadata schemas
 */
declare const MAP_SUPPORTED_FIELDS: readonly ["objects", "apps", "pages", "dashboards", "reports", "actions", "themes", "workflows", "approvals", "flows", "roles", "permissions", "sharingRules", "policies", "apis", "webhooks", "agents", "ragPipelines", "hooks", "mappings", "analyticsCubes", "connectors", "datasources"];
type MapSupportedField = (typeof MAP_SUPPORTED_FIELDS)[number];
/**
 * Normalize a single metadata collection value from map format to array format.
 * If the input is already an array (or nullish), it is returned unchanged.
 * If the input is a plain object (map), it is converted to an array where
 * each key is injected as the `name` field of the corresponding item.
 *
 * **Precedence:** If an item already has a `name` property, it is preserved
 * (the map key is only used as a fallback).
 *
 * @param value - The raw input value (array, map, or nullish)
 * @param keyField - The field name to inject the key into (default: `'name'`)
 * @returns The normalized array, or the original value if already an array/nullish
 *
 * @example
 * ```ts
 * // Map input
 * normalizeMetadataCollection({
 *   account: { fields: { name: { type: 'text' } } },
 *   contact: { fields: { email: { type: 'email' } } },
 * });
 * // → [
 * //   { name: 'account', fields: { name: { type: 'text' } } },
 * //   { name: 'contact', fields: { email: { type: 'email' } } },
 * // ]
 *
 * // Array input (pass-through)
 * normalizeMetadataCollection([{ name: 'account', fields: {} }]);
 * // → [{ name: 'account', fields: {} }]
 * ```
 */
declare function normalizeMetadataCollection(value: unknown, keyField?: string): unknown;
/**
 * Normalize all metadata collections in a stack definition input.
 * Converts any map-formatted collections to arrays with key→name injection.
 *
 * This function is applied to the raw input before Zod validation,
 * ensuring the canonical internal format is always arrays.
 *
 * @param input - The raw stack definition input
 * @returns A new object with all map collections normalized to arrays
 */
declare function normalizeStackInput<T extends Record<string, unknown>>(input: T): T;
/**
 * Mapping of legacy / alternative field names to their canonical names
 * in `ObjectStackDefinitionSchema`.
 *
 * Plugins may use legacy names (e.g., `triggers` instead of `hooks`).
 * This map lets `normalizePluginMetadata()` rewrite them automatically.
 */
declare const METADATA_ALIASES: Record<string, MapSupportedField>;
/**
 * Normalize plugin metadata so it matches the canonical format expected by the runtime.
 *
 * This handles two issues that commonly arise when loading third-party plugin metadata:
 *
 * 1. **Map → Array conversion** — plugins often define metadata as maps
 *    (e.g., `actions: { convert_lead: { ... } }`), but the runtime expects arrays.
 *    Every key listed in {@link MAP_SUPPORTED_FIELDS} is normalized via
 *    {@link normalizeMetadataCollection}.
 *
 * 2. **Field aliasing** — plugins may use legacy or alternative field names
 *    (e.g., `triggers` instead of `hooks`). {@link METADATA_ALIASES} maps them
 *    to their canonical counterparts.
 *
 * 3. **Recursive normalization** — if the plugin itself contains nested `plugins`,
 *    each nested plugin is normalized recursively.
 *
 * @param metadata - Raw plugin metadata object
 * @returns A new object with all collections normalized to arrays, aliases resolved,
 *          and nested plugins recursively normalized
 *
 * @example
 * ```ts
 * const raw = {
 *   actions: { lead_convert: { type: 'custom', label: 'Convert' } },
 *   triggers: { lead_scoring: { object: 'lead', event: 'afterInsert' } },
 * };
 * const normalized = normalizePluginMetadata(raw);
 * // normalized.actions → [{ name: 'lead_convert', type: 'custom', label: 'Convert' }]
 * // normalized.hooks   → [{ name: 'lead_scoring', object: 'lead', event: 'afterInsert' }]
 * // normalized.triggers → removed (merged into hooks)
 * ```
 */
declare function normalizePluginMetadata<T extends Record<string, unknown>>(metadata: T): T;

/**
 * Shared Schemas and Utilities
 * Common schemas used across multiple modules
 */

type index_AggregationFunction = AggregationFunction;
declare const index_AggregationFunctionEnum: typeof AggregationFunctionEnum;
type index_AppName = AppName;
declare const index_AppNameSchema: typeof AppNameSchema;
type index_BaseMetadataRecord = BaseMetadataRecord;
declare const index_BaseMetadataRecordSchema: typeof BaseMetadataRecordSchema;
type index_CacheStrategy = CacheStrategy;
declare const index_CacheStrategyEnum: typeof CacheStrategyEnum;
declare const index_CorsConfig: typeof CorsConfig;
declare const index_CorsConfigSchema: typeof CorsConfigSchema;
type index_EventName = EventName;
declare const index_EventNameSchema: typeof EventNameSchema;
type index_FieldMapping = FieldMapping;
declare const index_FieldMappingSchema: typeof FieldMappingSchema;
type index_FieldName = FieldName;
declare const index_FieldNameSchema: typeof FieldNameSchema;
type index_FlowName = FlowName;
declare const index_FlowNameSchema: typeof FlowNameSchema;
declare const index_HttpMethod: typeof HttpMethod;
declare const index_HttpMethodSchema: typeof HttpMethodSchema;
declare const index_HttpMethodType: typeof HttpMethodType;
declare const index_HttpRequest: typeof HttpRequest;
declare const index_HttpRequestSchema: typeof HttpRequestSchema;
type index_IsolationLevel = IsolationLevel;
declare const index_IsolationLevelEnum: typeof IsolationLevelEnum;
declare const index_MAP_SUPPORTED_FIELDS: typeof MAP_SUPPORTED_FIELDS;
declare const index_METADATA_ALIASES: typeof METADATA_ALIASES;
type index_MapSupportedField = MapSupportedField;
type index_MetadataCollectionInput<T> = MetadataCollectionInput<T>;
type index_MetadataFormat = MetadataFormat;
declare const index_MetadataFormatSchema: typeof MetadataFormatSchema;
type index_MutationEvent = MutationEvent;
declare const index_MutationEventEnum: typeof MutationEventEnum;
type index_ObjectName = ObjectName;
declare const index_ObjectNameSchema: typeof ObjectNameSchema;
type index_ObjectStackRawIssue = ObjectStackRawIssue;
declare const index_RateLimitConfig: typeof RateLimitConfig;
declare const index_RateLimitConfigSchema: typeof RateLimitConfigSchema;
type index_RoleName = RoleName;
declare const index_RoleNameSchema: typeof RoleNameSchema;
type index_SnakeCaseIdentifier = SnakeCaseIdentifier;
declare const index_SnakeCaseIdentifierSchema: typeof SnakeCaseIdentifierSchema;
type index_SortDirection = SortDirection;
declare const index_SortDirectionEnum: typeof SortDirectionEnum;
type index_SortItem = SortItem;
declare const index_SortItemSchema: typeof SortItemSchema;
declare const index_StaticMount: typeof StaticMount;
declare const index_StaticMountSchema: typeof StaticMountSchema;
type index_SystemIdentifier = SystemIdentifier;
declare const index_SystemIdentifierSchema: typeof SystemIdentifierSchema;
type index_TransformType = TransformType;
declare const index_TransformTypeSchema: typeof TransformTypeSchema;
type index_ViewName = ViewName;
declare const index_ViewNameSchema: typeof ViewNameSchema;
declare const index_findClosestMatches: typeof findClosestMatches;
declare const index_formatSuggestion: typeof formatSuggestion;
declare const index_formatZodError: typeof formatZodError;
declare const index_formatZodIssue: typeof formatZodIssue;
declare const index_levenshteinDistance: typeof levenshteinDistance;
declare const index_normalizeMetadataCollection: typeof normalizeMetadataCollection;
declare const index_normalizePluginMetadata: typeof normalizePluginMetadata;
declare const index_normalizeStackInput: typeof normalizeStackInput;
declare const index_objectStackErrorMap: typeof objectStackErrorMap;
declare const index_safeParsePretty: typeof safeParsePretty;
declare const index_suggestFieldType: typeof suggestFieldType;
declare namespace index {
  export { type index_AggregationFunction as AggregationFunction, index_AggregationFunctionEnum as AggregationFunctionEnum, type index_AppName as AppName, index_AppNameSchema as AppNameSchema, type index_BaseMetadataRecord as BaseMetadataRecord, index_BaseMetadataRecordSchema as BaseMetadataRecordSchema, type index_CacheStrategy as CacheStrategy, index_CacheStrategyEnum as CacheStrategyEnum, index_CorsConfig as CorsConfig, index_CorsConfigSchema as CorsConfigSchema, type index_EventName as EventName, index_EventNameSchema as EventNameSchema, type index_FieldMapping as FieldMapping, index_FieldMappingSchema as FieldMappingSchema, type index_FieldName as FieldName, index_FieldNameSchema as FieldNameSchema, type index_FlowName as FlowName, index_FlowNameSchema as FlowNameSchema, index_HttpMethod as HttpMethod, index_HttpMethodSchema as HttpMethodSchema, index_HttpMethodType as HttpMethodType, index_HttpRequest as HttpRequest, index_HttpRequestSchema as HttpRequestSchema, type index_IsolationLevel as IsolationLevel, index_IsolationLevelEnum as IsolationLevelEnum, index_MAP_SUPPORTED_FIELDS as MAP_SUPPORTED_FIELDS, index_METADATA_ALIASES as METADATA_ALIASES, type index_MapSupportedField as MapSupportedField, type index_MetadataCollectionInput as MetadataCollectionInput, type index_MetadataFormat as MetadataFormat, index_MetadataFormatSchema as MetadataFormatSchema, type index_MutationEvent as MutationEvent, index_MutationEventEnum as MutationEventEnum, type index_ObjectName as ObjectName, index_ObjectNameSchema as ObjectNameSchema, type index_ObjectStackRawIssue as ObjectStackRawIssue, index_RateLimitConfig as RateLimitConfig, index_RateLimitConfigSchema as RateLimitConfigSchema, type index_RoleName as RoleName, index_RoleNameSchema as RoleNameSchema, type index_SnakeCaseIdentifier as SnakeCaseIdentifier, index_SnakeCaseIdentifierSchema as SnakeCaseIdentifierSchema, type index_SortDirection as SortDirection, index_SortDirectionEnum as SortDirectionEnum, type index_SortItem as SortItem, index_SortItemSchema as SortItemSchema, index_StaticMount as StaticMount, index_StaticMountSchema as StaticMountSchema, type index_SystemIdentifier as SystemIdentifier, index_SystemIdentifierSchema as SystemIdentifierSchema, type index_TransformType as TransformType, index_TransformTypeSchema as TransformTypeSchema, type index_ViewName as ViewName, index_ViewNameSchema as ViewNameSchema, index_findClosestMatches as findClosestMatches, index_formatSuggestion as formatSuggestion, index_formatZodError as formatZodError, index_formatZodIssue as formatZodIssue, index_levenshteinDistance as levenshteinDistance, index_normalizeMetadataCollection as normalizeMetadataCollection, index_normalizePluginMetadata as normalizePluginMetadata, index_normalizeStackInput as normalizeStackInput, index_objectStackErrorMap as objectStackErrorMap, index_safeParsePretty as safeParsePretty, index_suggestFieldType as suggestFieldType };
}

export { levenshteinDistance as $, AggregationFunctionEnum as A, type MutationEvent as B, type IsolationLevel as C, CacheStrategyEnum as D, EventNameSchema as E, FieldMappingSchema as F, type CacheStrategy as G, MetadataFormatSchema as H, IsolationLevelEnum as I, type MetadataFormat as J, BaseMetadataRecordSchema as K, type BaseMetadataRecord as L, type MapSupportedField as M, type ObjectName as N, ObjectNameSchema as O, FieldNameSchema as P, type FieldName as Q, type ViewName as R, SystemIdentifierSchema as S, TransformTypeSchema as T, AppNameSchema as U, ViewNameSchema as V, type AppName as W, FlowNameSchema as X, type FlowName as Y, RoleNameSchema as Z, type RoleName as _, type MetadataCollectionInput as a, type ObjectStackRawIssue as a0, formatZodIssue as b, suggestFieldType as c, findClosestMatches as d, formatSuggestion as e, formatZodError as f, normalizeStackInput as g, normalizePluginMetadata as h, index as i, MAP_SUPPORTED_FIELDS as j, METADATA_ALIASES as k, SnakeCaseIdentifierSchema as l, type SystemIdentifier as m, normalizeMetadataCollection as n, objectStackErrorMap as o, type SnakeCaseIdentifier as p, type EventName as q, type TransformType as r, safeParsePretty as s, type FieldMapping as t, type AggregationFunction as u, SortDirectionEnum as v, type SortDirection as w, SortItemSchema as x, type SortItem as y, MutationEventEnum as z };
