import { AlgebraicConnectivity, ArcTransitive, BinaryTree, Branchwidth, Cage, CartesianProduct, Chordal, ChromaticNumber, Circumference, ClawFree, Cograph, CommunityStructure, Comparability, CompleteBipartite, Completeness, Connectivity, Cubic, Cycles, DegreeConstraint, Density, Diameter, Directionality, DominationNumber, EdgeArity, EdgeData, EdgeMultiplicity, EdgeOrdering, EdgeTransitive, Embedding, Eulerian, FlowNetwork, Girth, Grid, Hamiltonian, HereditaryClass, IndependenceNumber, Integrity, Interval, KColorable, KEdgeConnected, KVertexConnected, Layering, LexicographicProduct, Line, MeasureSemantics, MinorFree, MooreGraph, Observability, OperationalSemantics, Partiteness, Perfect, PerfectMatching, Permutation, Ports, Radius, Ramanujan, Rooting, ScaleFree, SchemaHomogeneity, SelfComplementary, SelfLoops, Signedness, SmallWorld, SpanningTree, SpecificRegular, SpectralRadius, Spectrum, Split, Star, StronglyRegular, StrongProduct, Temporal, TensorProduct, Threshold, TopologicalMinorFree, Toroidal, Toughness, Tournament, Traceable, Treewidth, Uncertainty, UnitDisk, VertexCardinality, VertexCover, VertexData, VertexIdentity, VertexOrdering, VertexTransitive, Weighting, Wheel } from './spec/index.js';
import { ATFree, BullFree, C5Free, CircularArc, Cliquewidth, Disk, DistanceHereditary, GemFree, HHFree, Modular, P5Free, Pathwidth, Planar, ProbeChordal, ProbeInterval, ProperCircularArc, Ptolemaic, QuasiLine } from './spec/new-classes-index.js';
/**
 * Complete graph specification with all 46 property axes.
 * Uses discriminated unions for type-safe property composition.
 */
export type GraphSpec = Readonly<{
    directionality: Directionality;
    weighting: Weighting;
    cycles: Cycles;
    connectivity: Connectivity;
    schema: SchemaHomogeneity;
    edgeMultiplicity: EdgeMultiplicity;
    selfLoops: SelfLoops;
    density: Density;
    completeness: Completeness;
    vertexCardinality?: VertexCardinality;
    vertexIdentity?: VertexIdentity;
    vertexOrdering?: VertexOrdering;
    edgeArity?: EdgeArity;
    signedness?: Signedness;
    uncertainty?: Uncertainty;
    vertexData?: VertexData;
    edgeData?: EdgeData;
    degreeConstraint?: DegreeConstraint;
    partiteness?: Partiteness;
    embedding?: Embedding;
    rooting?: Rooting;
    temporal?: Temporal;
    layering?: Layering;
    edgeOrdering?: EdgeOrdering;
    ports?: Ports;
    observability?: Observability;
    operationalSemantics?: OperationalSemantics;
    measureSemantics?: MeasureSemantics;
    scaleFree?: ScaleFree;
    smallWorld?: SmallWorld;
    communityStructure?: CommunityStructure;
    unitDisk?: UnitDisk;
    planar?: Planar;
    hamiltonian?: Hamiltonian;
    traceable?: Traceable;
    perfect?: Perfect;
    split?: Split;
    cograph?: Cograph;
    threshold?: Threshold;
    line?: Line;
    clawFree?: ClawFree;
    cubic?: Cubic;
    specificRegular?: SpecificRegular;
    stronglyRegular?: StronglyRegular;
    selfComplementary?: SelfComplementary;
    vertexTransitive?: VertexTransitive;
    edgeTransitive?: EdgeTransitive;
    arcTransitive?: ArcTransitive;
    diameter?: Diameter;
    radius?: Radius;
    girth?: Girth;
    circumference?: Circumference;
    hereditaryClass?: HereditaryClass;
    independenceNumber?: IndependenceNumber;
    vertexCover?: VertexCover;
    dominationNumber?: DominationNumber;
    spectrum?: Spectrum;
    algebraicConnectivity?: AlgebraicConnectivity;
    spectralRadius?: SpectralRadius;
    toughness?: Toughness;
    integrity?: Integrity;
    cage?: Cage;
    moore?: MooreGraph;
    ramanujan?: Ramanujan;
    cartesianProduct?: CartesianProduct;
    tensorProduct?: TensorProduct;
    strongProduct?: StrongProduct;
    lexicographicProduct?: LexicographicProduct;
    minorFree?: MinorFree;
    topologicalMinorFree?: TopologicalMinorFree;
    completeBipartite?: CompleteBipartite;
    eulerian?: Eulerian;
    kVertexConnected?: KVertexConnected;
    kEdgeConnected?: KEdgeConnected;
    wheel?: Wheel;
    grid?: Grid;
    toroidal?: Toroidal;
    star?: Star;
    comparability?: Comparability;
    interval?: Interval;
    permutation?: Permutation;
    chordal?: Chordal;
    perfectMatching?: PerfectMatching;
    kColorable?: KColorable;
    chromaticNumber?: ChromaticNumber;
    treewidth?: Treewidth;
    branchwidth?: Branchwidth;
    flowNetwork?: FlowNetwork;
    binaryTree?: BinaryTree;
    spanningTree?: SpanningTree;
    tournament?: Tournament;
    p5Free?: P5Free;
    c5Free?: C5Free;
    bullFree?: BullFree;
    gemFree?: GemFree;
    atFree?: ATFree;
    hhFree?: HHFree;
    distanceHereditary?: DistanceHereditary;
    circularArc?: CircularArc;
    properCircularArc?: ProperCircularArc;
    diskGraphNew?: Disk;
    probeChordal?: ProbeChordal;
    probeInterval?: ProbeInterval;
    pathwidth?: Pathwidth;
    cliquewidth?: Cliquewidth;
    modular?: Modular;
    ptolemaic?: Ptolemaic;
    quasiLine?: QuasiLine;
    planarNew?: Planar;
}>;
/** Default graph specification for common cases */
export declare const defaultGraphSpec: GraphSpec;
/** Helper type for partial specifications */
export type GraphSpecPatch = Partial<Omit<GraphSpec, "vertexCardinality" | "vertexIdentity" | "vertexOrdering" | "edgeArity" | "signedness" | "uncertainty" | "vertexData" | "edgeData" | "degreeConstraint" | "partiteness" | "embedding" | "rooting" | "temporal" | "layering" | "edgeOrdering" | "ports" | "observability" | "operationalSemantics" | "measureSemantics" | "scaleFree" | "smallWorld" | "communityStructure" | "unitDisk" | "planar" | "hamiltonian" | "traceable" | "perfect" | "split" | "cograph" | "threshold" | "line" | "clawFree" | "cubic" | "specificRegular" | "stronglyRegular" | "selfComplementary" | "vertexTransitive" | "edgeTransitive" | "arcTransitive" | "diameter" | "radius" | "girth" | "circumference" | "hereditaryClass" | "independenceNumber" | "vertexCover" | "dominationNumber" | "spectrum" | "algebraicConnectivity" | "spectralRadius" | "toughness" | "integrity" | "cage" | "moore" | "ramanujan" | "cartesianProduct" | "tensorProduct" | "strongProduct" | "lexicographicProduct" | "minorFree" | "topologicalMinorFree" | "completeBipartite">>;
/**
 * Create a GraphSpec from defaults + overrides.
 * Provides type-safe property composition.
 * @param patch
 */
export declare const makeGraphSpec: (patch?: GraphSpecPatch) => GraphSpec;
/** Type-level intersection for simple undirected graphs */
export type SimpleUndirectedGraphSpec = GraphSpec & Readonly<{
    edgeMultiplicity: {
        kind: "simple";
    };
    selfLoops: {
        kind: "disallowed";
    };
    directionality: {
        kind: "undirected";
    };
}>;
export declare const simpleUndirectedGraph: SimpleUndirectedGraphSpec;
/** Type-level intersection for simple directed graphs */
export type SimpleDirectedGraphSpec = GraphSpec & Readonly<{
    edgeMultiplicity: {
        kind: "simple";
    };
    selfLoops: {
        kind: "disallowed";
    };
    directionality: {
        kind: "directed";
    };
}>;
export declare const simpleDirectedGraph: SimpleDirectedGraphSpec;
/** DAG specification */
export type DAGSpec = GraphSpec & Readonly<{
    directionality: {
        kind: "directed";
    };
    cycles: {
        kind: "acyclic";
    };
    edgeMultiplicity: {
        kind: "simple";
    };
    selfLoops: {
        kind: "disallowed";
    };
}>;
export declare const dag: DAGSpec;
/** Tree specification */
export type TreeSpec = GraphSpec & Readonly<{
    directionality: {
        kind: "undirected";
    };
    cycles: {
        kind: "acyclic";
    };
    connectivity: {
        kind: "connected";
    };
    edgeMultiplicity: {
        kind: "simple";
    };
    selfLoops: {
        kind: "disallowed";
    };
}>;
export declare const tree: TreeSpec;
/** Weighted directed network */
export type WeightedDirectedNetworkSpec = GraphSpec & Readonly<{
    directionality: {
        kind: "directed";
    };
    weighting: {
        kind: "weighted_numeric";
    };
}>;
export declare const weightedDirectedNetwork: WeightedDirectedNetworkSpec;
/**
 * Generate all valid permutations of core GraphSpec properties.
 * Filters out invalid combinations (e.g., connected + acyclic + complete).
 */
export declare const generateCoreSpecPermutations: () => GraphSpec[];
/**
 * Validate that a GraphSpec doesn't contain contradictory properties.
 * @param spec
 */
export declare const isValidSpec: (spec: GraphSpec) => boolean;
/**
 * Generate a human-readable description of a GraphSpec.
 * @param spec
 */
export declare const describeSpec: (spec: GraphSpec) => string;
/**
 * Convenience helper for creating specs with commonly-used properties
 * @param overrides
 */
export declare const createSpec: (overrides?: GraphSpecPatch) => GraphSpec;
/**
 * Type guard for directed graphs
 * @param spec
 */
export declare const isDirected: (spec: GraphSpec) => spec is GraphSpec & {
    directionality: {
        kind: "directed";
    };
};
/**
 * Type guard for weighted graphs
 * @param spec
 */
export declare const isWeighted: (spec: GraphSpec) => spec is GraphSpec & {
    weighting: {
        kind: "weighted_numeric";
    };
};
/**
 * Type guard for acyclic graphs
 * @param spec
 */
export declare const isAcyclic: (spec: GraphSpec) => spec is GraphSpec & {
    cycles: {
        kind: "acyclic";
    };
};
/**
 * Type guard for connected graphs
 * @param spec
 */
export declare const isConnected: (spec: GraphSpec) => spec is GraphSpec & {
    connectivity: {
        kind: "connected";
    };
};
/**
 * Type guard for heterogeneous graphs
 * @param spec
 */
export declare const isHeterogeneous: (spec: GraphSpec) => spec is GraphSpec & {
    schema: {
        kind: "heterogeneous";
    };
};
/**
 * Type guard for multigraphs
 * @param spec
 */
export declare const isMultigraph: (spec: GraphSpec) => spec is GraphSpec & {
    edgeMultiplicity: {
        kind: "multi";
    };
};
/**
 * Type guard for graphs allowing self-loops
 * @param spec
 */
export declare const allowsSelfLoops: (spec: GraphSpec) => spec is GraphSpec & {
    selfLoops: {
        kind: "allowed";
    };
};
export { type AlgebraicConnectivity, type ArcTransitive, type BinaryTree, type Branchwidth, type Cage, type CartesianProduct, type Chordal, type ChromaticNumber, type Circumference, type ClawFree, type Cograph, type CommunityStructure, type Comparability, type CompleteBipartite, type Completeness, type Connectivity, type Cubic, type Cycles, type DegreeConstraint, type Density, type Diameter, type Directionality, type DominationNumber, type EdgeArity, type EdgeData, type EdgeMultiplicity, type EdgeOrdering, type EdgeTransitive, type Embedding, type Eulerian, type FlowNetwork, type Girth, type Grid, type Hamiltonian, type HereditaryClass, type IndependenceNumber, type Integrity, type Interval, type KColorable, type KEdgeConnected, type KVertexConnected, type Layering, type LexicographicProduct, type Line, type MeasureSemantics, type MinorFree, type MooreGraph, type Observability, type OperationalSemantics, type Partiteness, type Perfect, type PerfectMatching, type Permutation, type Planar, type Ports, type Radius, type Ramanujan, type Rooting, type ScaleFree, type SchemaHomogeneity, type SelfComplementary, type SelfLoops, type Signedness, type SmallWorld, type SpanningTree, type SpecificRegular, type SpectralRadius, type Spectrum, type Split, type Star, type StronglyRegular, type StrongProduct, type Temporal, type TensorProduct, type Threshold, type TopologicalMinorFree, type Toroidal, type Toughness, type Tournament, type Traceable, type Treewidth, type Uncertainty, type UnitDisk, type VertexCardinality, type VertexCover, type VertexData, type VertexIdentity, type VertexOrdering, type VertexTransitive, type Weighting, type Wheel } from './spec/index.js';
//# sourceMappingURL=spec.d.ts.map