import { z } from "zod";
import { type ConceptId } from "./concepts";
/**
 * Manifest Layer - Authority hierarchy
 * L1 = Domain (restricts business meaning)
 * L2 = Cluster (enforces regulation & workflow)
 * L3 = Cell (executes per tenant)
 */
export declare const ManifestLayerSchema: z.ZodEnum<["L1", "L2", "L3"]>;
export type ManifestLayer = z.infer<typeof ManifestLayerSchema>;
/**
 * Target Type - What the manifest governs
 */
export declare const TargetTypeSchema: z.ZodEnum<["domain", "cluster", "tenant"]>;
export type TargetType = z.infer<typeof TargetTypeSchema>;
/**
 * Business Standard - Regulatory framework reference
 */
export declare const BusinessStandardSchema: z.ZodEnum<["IFRS", "MFRS", "LOCAL", "INTERNAL"]>;
export type BusinessStandard = z.infer<typeof BusinessStandardSchema>;
/**
 * CRUD-S Operation - Extended CRUD with Soft-delete and Restore
 */
export declare const CrudOperationSchema: z.ZodEnum<["create", "read", "update", "delete", "restore"]>;
export type CrudOperation = z.infer<typeof CrudOperationSchema>;
export declare const ConceptIdSchema: z.ZodEnum<[ConceptId, ...ConceptId[]]>;
/**
 * Role ID - Reference to RBAC role
 * Can be "*" for any role (use sparingly)
 */
export declare const RoleIdSchema: z.ZodString;
/**
 * Value Set ID - Reference to kernel value set
 */
export declare const ValueSetIdSchema: z.ZodString;
/**
 * Value ID - Reference to value within a value set
 */
export declare const ValueIdSchema: z.ZodString;
/**
 * Semver - Semantic versioning pattern
 */
export declare const SemverSchema: z.ZodString;
/**
 * CRUD-S Permission - Roles allowed for each operation
 *
 * @example
 * ```typescript
 * const crud: CrudPermission = {
 *   create: ["admin", "manager"],
 *   read: ["*"], // Any role can read
 *   update: ["admin", "manager"],
 *   delete: ["admin"], // Soft-delete only
 *   restore: ["admin"],
 * };
 * ```
 */
export declare const CrudPermissionSchema: z.ZodObject<{
    create: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    read: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    update: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    delete: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    restore: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
}, "strip", z.ZodTypeAny, {
    create: string[];
    read: string[];
    update: string[];
    delete: string[];
    restore: string[];
}, {
    create?: string[] | undefined;
    read?: string[] | undefined;
    update?: string[] | undefined;
    delete?: string[] | undefined;
    restore?: string[] | undefined;
}>;
export type CrudPermission = z.infer<typeof CrudPermissionSchema>;
/**
 * Integrity Constraints - Field immutability and required relations
 *
 * @example
 * ```typescript
 * const integrity: IntegrityConstraint = {
 *   immutable_fields: ["id", "created_at", "vendor_id"],
 *   required_relations: ["CONCEPT_VENDOR", "CONCEPT_COMPANY"],
 * };
 * ```
 */
export declare const IntegrityConstraintSchema: z.ZodObject<{
    /** Fields that cannot be updated after creation */
    immutable_fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    /** Related concepts that must exist (ACID atomicity) */
    required_relations: z.ZodDefault<z.ZodArray<z.ZodEnum<[ConceptId, ...ConceptId[]]>, "many">>;
}, "strip", z.ZodTypeAny, {
    immutable_fields: string[];
    required_relations: ConceptId[];
}, {
    immutable_fields?: string[] | undefined;
    required_relations?: ConceptId[] | undefined;
}>;
export type IntegrityConstraint = z.infer<typeof IntegrityConstraintSchema>;
/**
 * Workflow Definition - State machine for concept lifecycle
 *
 * @example
 * ```typescript
 * const workflow: WorkflowDefinition = {
 *   states: "VALUESET_INVOICE_STATUS",
 *   initial: "RECEIVED",
 *   transitions: {
 *     RECEIVED: ["UNDER_REVIEW", "REJECTED"],
 *     UNDER_REVIEW: ["APPROVED_FOR_PAYMENT", "REJECTED"],
 *     APPROVED_FOR_PAYMENT: ["PAID"],
 *     REJECTED: [], // Terminal state
 *     PAID: [], // Terminal state
 *   },
 *   requires_comment: {
 *     REJECTED: true,
 *   },
 * };
 * ```
 */
export declare const WorkflowDefinitionSchema: z.ZodObject<{
    /** Value set containing valid states */
    states: z.ZodString;
    /** Initial state for new entities */
    initial: z.ZodString;
    /** Allowed state transitions (from -> [to]) */
    transitions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
    /** States that require a comment when entering */
    requires_comment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
}, "strip", z.ZodTypeAny, {
    states: string;
    initial: string;
    transitions: Record<string, string[]>;
    requires_comment?: Record<string, boolean> | undefined;
}, {
    states: string;
    initial: string;
    transitions: Record<string, string[]>;
    requires_comment?: Record<string, boolean> | undefined;
}>;
export type WorkflowDefinition = z.infer<typeof WorkflowDefinitionSchema>;
/**
 * Business Reference - Regulatory/standard alignment
 *
 * @example
 * ```typescript
 * const ref: BusinessReference = {
 *   standard: "IFRS",
 *   reference: "IAS 41 - Agriculture",
 *   notes: "Biological assets valuation",
 * };
 * ```
 */
export declare const BusinessReferenceSchema: z.ZodObject<{
    standard: z.ZodEnum<["IFRS", "MFRS", "LOCAL", "INTERNAL"]>;
    reference: z.ZodString;
    notes: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
    reference: string;
    notes?: string | undefined;
}, {
    standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
    reference: string;
    notes?: string | undefined;
}>;
export type BusinessReference = z.infer<typeof BusinessReferenceSchema>;
/**
 * Concept Policy - Full governance rules for a single concept
 *
 * @example
 * ```typescript
 * const invoicePolicy: ConceptPolicy = {
 *   crud: {
 *     create: ["vendor", "admin"],
 *     read: ["*"],
 *     update: ["admin", "manager"],
 *     delete: ["admin"],
 *     restore: ["admin"],
 *   },
 *   integrity: {
 *     immutable_fields: ["id", "invoice_number", "vendor_id"],
 *     required_relations: ["CONCEPT_VENDOR"],
 *   },
 *   workflow: {
 *     states: "VALUESET_INVOICE_STATUS",
 *     initial: "RECEIVED",
 *     transitions: { ... },
 *   },
 *   business_reference: {
 *     standard: "IFRS",
 *     reference: "IFRS 15 - Revenue Recognition",
 *   },
 * };
 * ```
 */
export declare const ConceptPolicySchema: z.ZodObject<{
    /** CRUD-S permissions */
    crud: z.ZodObject<{
        create: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        read: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        update: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        delete: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        restore: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
    }, "strip", z.ZodTypeAny, {
        create: string[];
        read: string[];
        update: string[];
        delete: string[];
        restore: string[];
    }, {
        create?: string[] | undefined;
        read?: string[] | undefined;
        update?: string[] | undefined;
        delete?: string[] | undefined;
        restore?: string[] | undefined;
    }>;
    /** Integrity constraints */
    integrity: z.ZodOptional<z.ZodObject<{
        /** Fields that cannot be updated after creation */
        immutable_fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        /** Related concepts that must exist (ACID atomicity) */
        required_relations: z.ZodDefault<z.ZodArray<z.ZodEnum<[ConceptId, ...ConceptId[]]>, "many">>;
    }, "strip", z.ZodTypeAny, {
        immutable_fields: string[];
        required_relations: ConceptId[];
    }, {
        immutable_fields?: string[] | undefined;
        required_relations?: ConceptId[] | undefined;
    }>>;
    /** Workflow definition */
    workflow: z.ZodOptional<z.ZodObject<{
        /** Value set containing valid states */
        states: z.ZodString;
        /** Initial state for new entities */
        initial: z.ZodString;
        /** Allowed state transitions (from -> [to]) */
        transitions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
        /** States that require a comment when entering */
        requires_comment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
    }, "strip", z.ZodTypeAny, {
        states: string;
        initial: string;
        transitions: Record<string, string[]>;
        requires_comment?: Record<string, boolean> | undefined;
    }, {
        states: string;
        initial: string;
        transitions: Record<string, string[]>;
        requires_comment?: Record<string, boolean> | undefined;
    }>>;
    /** Business/regulatory reference */
    business_reference: z.ZodOptional<z.ZodObject<{
        standard: z.ZodEnum<["IFRS", "MFRS", "LOCAL", "INTERNAL"]>;
        reference: z.ZodString;
        notes: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
        reference: string;
        notes?: string | undefined;
    }, {
        standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
        reference: string;
        notes?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    crud: {
        create: string[];
        read: string[];
        update: string[];
        delete: string[];
        restore: string[];
    };
    integrity?: {
        immutable_fields: string[];
        required_relations: ConceptId[];
    } | undefined;
    workflow?: {
        states: string;
        initial: string;
        transitions: Record<string, string[]>;
        requires_comment?: Record<string, boolean> | undefined;
    } | undefined;
    business_reference?: {
        standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
        reference: string;
        notes?: string | undefined;
    } | undefined;
}, {
    crud: {
        create?: string[] | undefined;
        read?: string[] | undefined;
        update?: string[] | undefined;
        delete?: string[] | undefined;
        restore?: string[] | undefined;
    };
    integrity?: {
        immutable_fields?: string[] | undefined;
        required_relations?: ConceptId[] | undefined;
    } | undefined;
    workflow?: {
        states: string;
        initial: string;
        transitions: Record<string, string[]>;
        requires_comment?: Record<string, boolean> | undefined;
    } | undefined;
    business_reference?: {
        standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
        reference: string;
        notes?: string | undefined;
    } | undefined;
}>;
export type ConceptPolicy = z.infer<typeof ConceptPolicySchema>;
/**
 * Manifest Definition - The governance rules within the JSONB `definition` column
 *
 * This is what gets stored in `sys_manifests.definition`
 */
export declare const ManifestDefinitionSchema: z.ZodObject<{
    /** Human-readable name */
    name: z.ZodString;
    /** Description */
    description: z.ZodOptional<z.ZodString>;
    /** Concept allowlist - only these concepts can be used in this scope */
    allowlist: z.ZodArray<z.ZodEnum<[ConceptId, ...ConceptId[]]>, "many">;
    /** Per-concept policies */
    policies: z.ZodOptional<z.ZodRecord<z.ZodEnum<[ConceptId, ...ConceptId[]]>, z.ZodObject<{
        /** CRUD-S permissions */
        crud: z.ZodObject<{
            create: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            read: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            update: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            delete: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            restore: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
        }, "strip", z.ZodTypeAny, {
            create: string[];
            read: string[];
            update: string[];
            delete: string[];
            restore: string[];
        }, {
            create?: string[] | undefined;
            read?: string[] | undefined;
            update?: string[] | undefined;
            delete?: string[] | undefined;
            restore?: string[] | undefined;
        }>;
        /** Integrity constraints */
        integrity: z.ZodOptional<z.ZodObject<{
            /** Fields that cannot be updated after creation */
            immutable_fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            /** Related concepts that must exist (ACID atomicity) */
            required_relations: z.ZodDefault<z.ZodArray<z.ZodEnum<[ConceptId, ...ConceptId[]]>, "many">>;
        }, "strip", z.ZodTypeAny, {
            immutable_fields: string[];
            required_relations: ConceptId[];
        }, {
            immutable_fields?: string[] | undefined;
            required_relations?: ConceptId[] | undefined;
        }>>;
        /** Workflow definition */
        workflow: z.ZodOptional<z.ZodObject<{
            /** Value set containing valid states */
            states: z.ZodString;
            /** Initial state for new entities */
            initial: z.ZodString;
            /** Allowed state transitions (from -> [to]) */
            transitions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
            /** States that require a comment when entering */
            requires_comment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
        }, "strip", z.ZodTypeAny, {
            states: string;
            initial: string;
            transitions: Record<string, string[]>;
            requires_comment?: Record<string, boolean> | undefined;
        }, {
            states: string;
            initial: string;
            transitions: Record<string, string[]>;
            requires_comment?: Record<string, boolean> | undefined;
        }>>;
        /** Business/regulatory reference */
        business_reference: z.ZodOptional<z.ZodObject<{
            standard: z.ZodEnum<["IFRS", "MFRS", "LOCAL", "INTERNAL"]>;
            reference: z.ZodString;
            notes: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
            reference: string;
            notes?: string | undefined;
        }, {
            standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
            reference: string;
            notes?: string | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        crud: {
            create: string[];
            read: string[];
            update: string[];
            delete: string[];
            restore: string[];
        };
        integrity?: {
            immutable_fields: string[];
            required_relations: ConceptId[];
        } | undefined;
        workflow?: {
            states: string;
            initial: string;
            transitions: Record<string, string[]>;
            requires_comment?: Record<string, boolean> | undefined;
        } | undefined;
        business_reference?: {
            standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
            reference: string;
            notes?: string | undefined;
        } | undefined;
    }, {
        crud: {
            create?: string[] | undefined;
            read?: string[] | undefined;
            update?: string[] | undefined;
            delete?: string[] | undefined;
            restore?: string[] | undefined;
        };
        integrity?: {
            immutable_fields?: string[] | undefined;
            required_relations?: ConceptId[] | undefined;
        } | undefined;
        workflow?: {
            states: string;
            initial: string;
            transitions: Record<string, string[]>;
            requires_comment?: Record<string, boolean> | undefined;
        } | undefined;
        business_reference?: {
            standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
            reference: string;
            notes?: string | undefined;
        } | undefined;
    }>>>;
    /** Metadata for extensibility */
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    name: string;
    allowlist: ConceptId[];
    description?: string | undefined;
    policies?: Partial<Record<ConceptId, {
        crud: {
            create: string[];
            read: string[];
            update: string[];
            delete: string[];
            restore: string[];
        };
        integrity?: {
            immutable_fields: string[];
            required_relations: ConceptId[];
        } | undefined;
        workflow?: {
            states: string;
            initial: string;
            transitions: Record<string, string[]>;
            requires_comment?: Record<string, boolean> | undefined;
        } | undefined;
        business_reference?: {
            standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
            reference: string;
            notes?: string | undefined;
        } | undefined;
    }>> | undefined;
    metadata?: Record<string, unknown> | undefined;
}, {
    name: string;
    allowlist: ConceptId[];
    description?: string | undefined;
    policies?: Partial<Record<ConceptId, {
        crud: {
            create?: string[] | undefined;
            read?: string[] | undefined;
            update?: string[] | undefined;
            delete?: string[] | undefined;
            restore?: string[] | undefined;
        };
        integrity?: {
            immutable_fields?: string[] | undefined;
            required_relations?: ConceptId[] | undefined;
        } | undefined;
        workflow?: {
            states: string;
            initial: string;
            transitions: Record<string, string[]>;
            requires_comment?: Record<string, boolean> | undefined;
        } | undefined;
        business_reference?: {
            standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
            reference: string;
            notes?: string | undefined;
        } | undefined;
    }>> | undefined;
    metadata?: Record<string, unknown> | undefined;
}>;
export type ManifestDefinition = z.infer<typeof ManifestDefinitionSchema>;
/**
 * Manifest - Full manifest record as stored in `sys_manifests` table
 *
 * @example
 * ```typescript
 * const manifest: Manifest = {
 *   id: "bb47987f-0217-4b42-9fcb-132b85152d67",
 *   layer: "L1",
 *   target_id: "VPM",
 *   target_type: "domain",
 *   kernel_snapshot_id: "sha256:abc123...",
 *   version: "1.0.0",
 *   is_active: true,
 *   is_current: true,
 *   definition: { ... },
 * };
 * ```
 */
export declare const ManifestSchema: z.ZodObject<{
    /** UUID primary key */
    id: z.ZodString;
    /** Manifest layer (L1/L2/L3) */
    layer: z.ZodEnum<["L1", "L2", "L3"]>;
    /** Target identifier (domain ID, cluster ID, or tenant ID) */
    target_id: z.ZodString;
    /** Target type */
    target_type: z.ZodEnum<["domain", "cluster", "tenant"]>;
    /** Kernel snapshot ID for version compliance */
    kernel_snapshot_id: z.ZodString;
    /** Manifest semantic version */
    version: z.ZodString;
    /** Is this manifest active? */
    is_active: z.ZodDefault<z.ZodBoolean>;
    /** Is this the current version? */
    is_current: z.ZodDefault<z.ZodBoolean>;
    /** Manifest definition (the actual rules) */
    definition: z.ZodObject<{
        /** Human-readable name */
        name: z.ZodString;
        /** Description */
        description: z.ZodOptional<z.ZodString>;
        /** Concept allowlist - only these concepts can be used in this scope */
        allowlist: z.ZodArray<z.ZodEnum<[ConceptId, ...ConceptId[]]>, "many">;
        /** Per-concept policies */
        policies: z.ZodOptional<z.ZodRecord<z.ZodEnum<[ConceptId, ...ConceptId[]]>, z.ZodObject<{
            /** CRUD-S permissions */
            crud: z.ZodObject<{
                create: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                read: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                update: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                delete: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                restore: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
            }, "strip", z.ZodTypeAny, {
                create: string[];
                read: string[];
                update: string[];
                delete: string[];
                restore: string[];
            }, {
                create?: string[] | undefined;
                read?: string[] | undefined;
                update?: string[] | undefined;
                delete?: string[] | undefined;
                restore?: string[] | undefined;
            }>;
            /** Integrity constraints */
            integrity: z.ZodOptional<z.ZodObject<{
                /** Fields that cannot be updated after creation */
                immutable_fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                /** Related concepts that must exist (ACID atomicity) */
                required_relations: z.ZodDefault<z.ZodArray<z.ZodEnum<[ConceptId, ...ConceptId[]]>, "many">>;
            }, "strip", z.ZodTypeAny, {
                immutable_fields: string[];
                required_relations: ConceptId[];
            }, {
                immutable_fields?: string[] | undefined;
                required_relations?: ConceptId[] | undefined;
            }>>;
            /** Workflow definition */
            workflow: z.ZodOptional<z.ZodObject<{
                /** Value set containing valid states */
                states: z.ZodString;
                /** Initial state for new entities */
                initial: z.ZodString;
                /** Allowed state transitions (from -> [to]) */
                transitions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
                /** States that require a comment when entering */
                requires_comment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
            }, "strip", z.ZodTypeAny, {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            }, {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            }>>;
            /** Business/regulatory reference */
            business_reference: z.ZodOptional<z.ZodObject<{
                standard: z.ZodEnum<["IFRS", "MFRS", "LOCAL", "INTERNAL"]>;
                reference: z.ZodString;
                notes: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            }, {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            }>>;
        }, "strip", z.ZodTypeAny, {
            crud: {
                create: string[];
                read: string[];
                update: string[];
                delete: string[];
                restore: string[];
            };
            integrity?: {
                immutable_fields: string[];
                required_relations: ConceptId[];
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }, {
            crud: {
                create?: string[] | undefined;
                read?: string[] | undefined;
                update?: string[] | undefined;
                delete?: string[] | undefined;
                restore?: string[] | undefined;
            };
            integrity?: {
                immutable_fields?: string[] | undefined;
                required_relations?: ConceptId[] | undefined;
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>>>;
        /** Metadata for extensibility */
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        allowlist: ConceptId[];
        description?: string | undefined;
        policies?: Partial<Record<ConceptId, {
            crud: {
                create: string[];
                read: string[];
                update: string[];
                delete: string[];
                restore: string[];
            };
            integrity?: {
                immutable_fields: string[];
                required_relations: ConceptId[];
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>> | undefined;
        metadata?: Record<string, unknown> | undefined;
    }, {
        name: string;
        allowlist: ConceptId[];
        description?: string | undefined;
        policies?: Partial<Record<ConceptId, {
            crud: {
                create?: string[] | undefined;
                read?: string[] | undefined;
                update?: string[] | undefined;
                delete?: string[] | undefined;
                restore?: string[] | undefined;
            };
            integrity?: {
                immutable_fields?: string[] | undefined;
                required_relations?: ConceptId[] | undefined;
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>> | undefined;
        metadata?: Record<string, unknown> | undefined;
    }>;
    /** Soft-delete timestamp */
    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Who soft-deleted this manifest */
    deleted_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Parent manifest ID (for inheritance) */
    parent_manifest_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Replacement manifest ID */
    replaced_by_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Audit: who created */
    created_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Audit: when created */
    created_at: z.ZodOptional<z.ZodString>;
    /** Audit: who last updated */
    updated_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Audit: when last updated */
    updated_at: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id: string;
    layer: "L1" | "L2" | "L3";
    target_id: string;
    target_type: "domain" | "cluster" | "tenant";
    kernel_snapshot_id: string;
    version: string;
    is_active: boolean;
    is_current: boolean;
    definition: {
        name: string;
        allowlist: ConceptId[];
        description?: string | undefined;
        policies?: Partial<Record<ConceptId, {
            crud: {
                create: string[];
                read: string[];
                update: string[];
                delete: string[];
                restore: string[];
            };
            integrity?: {
                immutable_fields: string[];
                required_relations: ConceptId[];
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>> | undefined;
        metadata?: Record<string, unknown> | undefined;
    };
    created_by?: string | null | undefined;
    created_at?: string | undefined;
    updated_by?: string | null | undefined;
    updated_at?: string | undefined;
    deleted_at?: string | null | undefined;
    deleted_by?: string | null | undefined;
    parent_manifest_id?: string | null | undefined;
    replaced_by_id?: string | null | undefined;
}, {
    id: string;
    layer: "L1" | "L2" | "L3";
    target_id: string;
    target_type: "domain" | "cluster" | "tenant";
    kernel_snapshot_id: string;
    version: string;
    definition: {
        name: string;
        allowlist: ConceptId[];
        description?: string | undefined;
        policies?: Partial<Record<ConceptId, {
            crud: {
                create?: string[] | undefined;
                read?: string[] | undefined;
                update?: string[] | undefined;
                delete?: string[] | undefined;
                restore?: string[] | undefined;
            };
            integrity?: {
                immutable_fields?: string[] | undefined;
                required_relations?: ConceptId[] | undefined;
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>> | undefined;
        metadata?: Record<string, unknown> | undefined;
    };
    created_by?: string | null | undefined;
    created_at?: string | undefined;
    updated_by?: string | null | undefined;
    updated_at?: string | undefined;
    is_active?: boolean | undefined;
    is_current?: boolean | undefined;
    deleted_at?: string | null | undefined;
    deleted_by?: string | null | undefined;
    parent_manifest_id?: string | null | undefined;
    replaced_by_id?: string | null | undefined;
}>;
export type Manifest = z.infer<typeof ManifestSchema>;
/**
 * ManifestCreateInput - Schema for creating a new manifest
 * Omits auto-generated fields
 */
export declare const ManifestCreateInputSchema: z.ZodObject<Omit<{
    /** UUID primary key */
    id: z.ZodString;
    /** Manifest layer (L1/L2/L3) */
    layer: z.ZodEnum<["L1", "L2", "L3"]>;
    /** Target identifier (domain ID, cluster ID, or tenant ID) */
    target_id: z.ZodString;
    /** Target type */
    target_type: z.ZodEnum<["domain", "cluster", "tenant"]>;
    /** Kernel snapshot ID for version compliance */
    kernel_snapshot_id: z.ZodString;
    /** Manifest semantic version */
    version: z.ZodString;
    /** Is this manifest active? */
    is_active: z.ZodDefault<z.ZodBoolean>;
    /** Is this the current version? */
    is_current: z.ZodDefault<z.ZodBoolean>;
    /** Manifest definition (the actual rules) */
    definition: z.ZodObject<{
        /** Human-readable name */
        name: z.ZodString;
        /** Description */
        description: z.ZodOptional<z.ZodString>;
        /** Concept allowlist - only these concepts can be used in this scope */
        allowlist: z.ZodArray<z.ZodEnum<[ConceptId, ...ConceptId[]]>, "many">;
        /** Per-concept policies */
        policies: z.ZodOptional<z.ZodRecord<z.ZodEnum<[ConceptId, ...ConceptId[]]>, z.ZodObject<{
            /** CRUD-S permissions */
            crud: z.ZodObject<{
                create: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                read: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                update: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                delete: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                restore: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
            }, "strip", z.ZodTypeAny, {
                create: string[];
                read: string[];
                update: string[];
                delete: string[];
                restore: string[];
            }, {
                create?: string[] | undefined;
                read?: string[] | undefined;
                update?: string[] | undefined;
                delete?: string[] | undefined;
                restore?: string[] | undefined;
            }>;
            /** Integrity constraints */
            integrity: z.ZodOptional<z.ZodObject<{
                /** Fields that cannot be updated after creation */
                immutable_fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                /** Related concepts that must exist (ACID atomicity) */
                required_relations: z.ZodDefault<z.ZodArray<z.ZodEnum<[ConceptId, ...ConceptId[]]>, "many">>;
            }, "strip", z.ZodTypeAny, {
                immutable_fields: string[];
                required_relations: ConceptId[];
            }, {
                immutable_fields?: string[] | undefined;
                required_relations?: ConceptId[] | undefined;
            }>>;
            /** Workflow definition */
            workflow: z.ZodOptional<z.ZodObject<{
                /** Value set containing valid states */
                states: z.ZodString;
                /** Initial state for new entities */
                initial: z.ZodString;
                /** Allowed state transitions (from -> [to]) */
                transitions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
                /** States that require a comment when entering */
                requires_comment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
            }, "strip", z.ZodTypeAny, {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            }, {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            }>>;
            /** Business/regulatory reference */
            business_reference: z.ZodOptional<z.ZodObject<{
                standard: z.ZodEnum<["IFRS", "MFRS", "LOCAL", "INTERNAL"]>;
                reference: z.ZodString;
                notes: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            }, {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            }>>;
        }, "strip", z.ZodTypeAny, {
            crud: {
                create: string[];
                read: string[];
                update: string[];
                delete: string[];
                restore: string[];
            };
            integrity?: {
                immutable_fields: string[];
                required_relations: ConceptId[];
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }, {
            crud: {
                create?: string[] | undefined;
                read?: string[] | undefined;
                update?: string[] | undefined;
                delete?: string[] | undefined;
                restore?: string[] | undefined;
            };
            integrity?: {
                immutable_fields?: string[] | undefined;
                required_relations?: ConceptId[] | undefined;
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>>>;
        /** Metadata for extensibility */
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        allowlist: ConceptId[];
        description?: string | undefined;
        policies?: Partial<Record<ConceptId, {
            crud: {
                create: string[];
                read: string[];
                update: string[];
                delete: string[];
                restore: string[];
            };
            integrity?: {
                immutable_fields: string[];
                required_relations: ConceptId[];
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>> | undefined;
        metadata?: Record<string, unknown> | undefined;
    }, {
        name: string;
        allowlist: ConceptId[];
        description?: string | undefined;
        policies?: Partial<Record<ConceptId, {
            crud: {
                create?: string[] | undefined;
                read?: string[] | undefined;
                update?: string[] | undefined;
                delete?: string[] | undefined;
                restore?: string[] | undefined;
            };
            integrity?: {
                immutable_fields?: string[] | undefined;
                required_relations?: ConceptId[] | undefined;
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>> | undefined;
        metadata?: Record<string, unknown> | undefined;
    }>;
    /** Soft-delete timestamp */
    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Who soft-deleted this manifest */
    deleted_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Parent manifest ID (for inheritance) */
    parent_manifest_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Replacement manifest ID */
    replaced_by_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Audit: who created */
    created_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Audit: when created */
    created_at: z.ZodOptional<z.ZodString>;
    /** Audit: who last updated */
    updated_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    /** Audit: when last updated */
    updated_at: z.ZodOptional<z.ZodString>;
}, "created_at" | "updated_at" | "id" | "deleted_at" | "deleted_by" | "replaced_by_id">, "strip", z.ZodTypeAny, {
    layer: "L1" | "L2" | "L3";
    target_id: string;
    target_type: "domain" | "cluster" | "tenant";
    kernel_snapshot_id: string;
    version: string;
    is_active: boolean;
    is_current: boolean;
    definition: {
        name: string;
        allowlist: ConceptId[];
        description?: string | undefined;
        policies?: Partial<Record<ConceptId, {
            crud: {
                create: string[];
                read: string[];
                update: string[];
                delete: string[];
                restore: string[];
            };
            integrity?: {
                immutable_fields: string[];
                required_relations: ConceptId[];
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>> | undefined;
        metadata?: Record<string, unknown> | undefined;
    };
    created_by?: string | null | undefined;
    updated_by?: string | null | undefined;
    parent_manifest_id?: string | null | undefined;
}, {
    layer: "L1" | "L2" | "L3";
    target_id: string;
    target_type: "domain" | "cluster" | "tenant";
    kernel_snapshot_id: string;
    version: string;
    definition: {
        name: string;
        allowlist: ConceptId[];
        description?: string | undefined;
        policies?: Partial<Record<ConceptId, {
            crud: {
                create?: string[] | undefined;
                read?: string[] | undefined;
                update?: string[] | undefined;
                delete?: string[] | undefined;
                restore?: string[] | undefined;
            };
            integrity?: {
                immutable_fields?: string[] | undefined;
                required_relations?: ConceptId[] | undefined;
            } | undefined;
            workflow?: {
                states: string;
                initial: string;
                transitions: Record<string, string[]>;
                requires_comment?: Record<string, boolean> | undefined;
            } | undefined;
            business_reference?: {
                standard: "INTERNAL" | "IFRS" | "MFRS" | "LOCAL";
                reference: string;
                notes?: string | undefined;
            } | undefined;
        }>> | undefined;
        metadata?: Record<string, unknown> | undefined;
    };
    created_by?: string | null | undefined;
    updated_by?: string | null | undefined;
    is_active?: boolean | undefined;
    is_current?: boolean | undefined;
    parent_manifest_id?: string | null | undefined;
}>;
export type ManifestCreateInput = z.infer<typeof ManifestCreateInputSchema>;
/**
 * Validate a manifest definition
 * @throws CanonError on validation failure
 */
export declare function validateManifestDefinition(input: unknown): ManifestDefinition;
/**
 * Validate a full manifest record
 * @throws CanonError on validation failure
 */
export declare function validateManifest(input: unknown): Manifest;
/**
 * Validate manifest create input
 * @throws CanonError on validation failure
 */
export declare function validateManifestCreateInput(input: unknown): ManifestCreateInput;
/**
 * Check if a concept is in the manifest allowlist
 */
export declare function isConceptAllowed(manifest: Manifest | ManifestDefinition, conceptId: ConceptId): boolean;
/**
 * Get the policy for a concept from a manifest
 */
export declare function getConceptPolicy(manifest: Manifest | ManifestDefinition, conceptId: ConceptId): ConceptPolicy | undefined;
/**
 * Check if a role can perform an operation on a concept
 */
export declare function canPerformOperation(manifest: Manifest | ManifestDefinition, conceptId: ConceptId, operation: CrudOperation, roleId: string): boolean;
/**
 * Validate a workflow state transition
 */
export declare function isValidTransition(workflow: WorkflowDefinition, fromState: string, toState: string): boolean;
/**
 * Check if a state transition requires a comment
 */
export declare function transitionRequiresComment(workflow: WorkflowDefinition, toState: string): boolean;
//# sourceMappingURL=manifest.d.ts.map