/**
 * JSON Structure Schema Type Definitions
 *
 * Based on JSON Structure Core specification
 * https://json-structure.org/
 */
export type PrimitiveType = 'string' | 'boolean' | 'null' | 'int8' | 'int16' | 'int32' | 'int64' | 'int128' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'uint128' | 'float' | 'double' | 'decimal' | 'date' | 'datetime' | 'time' | 'duration' | 'uuid' | 'uri' | 'binary';
export type CompoundType = 'object' | 'array' | 'set' | 'map' | 'tuple' | 'choice' | 'any';
export type TypeKeyword = PrimitiveType | CompoundType;
/** Integer types that require BigInt for full precision */
export type BigIntType = 'int64' | 'int128' | 'uint64' | 'uint128';
/** Check if a type requires BigInt handling */
export declare function isBigIntType(type: string): type is BigIntType;
/** All signed integer types */
export type SignedIntegerType = 'int8' | 'int16' | 'int32' | 'int64' | 'int128';
/** All unsigned integer types */
export type UnsignedIntegerType = 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'uint128';
/** All integer types */
export type IntegerType = SignedIntegerType | UnsignedIntegerType;
/** Check if a type is an integer type */
export declare function isIntegerType(type: string): type is IntegerType;
/** All floating-point types */
export type FloatType = 'float' | 'double' | 'decimal';
/** Check if a type is a floating-point type */
export declare function isFloatType(type: string): type is FloatType;
/** All numeric types */
export type NumericType = IntegerType | FloatType;
/** Check if a type is numeric */
export declare function isNumericType(type: string): type is NumericType;
/** All temporal types */
export type TemporalType = 'date' | 'datetime' | 'time' | 'duration';
/** Check if a type is temporal */
export declare function isTemporalType(type: string): type is TemporalType;
/** Check if a type is primitive */
export declare function isPrimitiveType(type: string): type is PrimitiveType;
/** Check if a type is compound/complex */
export declare function isCompoundType(type: string): type is CompoundType;
export interface TypeReference {
    $ref: string;
}
export type TypeSpecifier = TypeKeyword | TypeKeyword[] | TypeReference;
/** Check if a value is a type reference */
export declare function isTypeReference(value: unknown): value is TypeReference;
export interface StringValidation {
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    format?: string;
}
export interface NumericValidation {
    minimum?: number | string;
    maximum?: number | string;
    exclusiveMinimum?: number | string;
    exclusiveMaximum?: number | string;
    multipleOf?: number;
}
export interface ArrayValidation {
    minItems?: number;
    maxItems?: number;
    uniqueItems?: boolean;
    contains?: TypeDefinition;
    minContains?: number;
    maxContains?: number;
}
export interface ObjectValidation {
    minProperties?: number;
    maxProperties?: number;
    dependentRequired?: Record<string, string[]>;
}
export interface Altnames {
    json?: string;
    [key: `lang:${string}`]: string | undefined;
}
export interface TypeMetadata {
    name?: string;
    description?: string;
    examples?: unknown[];
    deprecated?: boolean;
    abstract?: boolean;
    altnames?: Altnames;
    unit?: string;
    currency?: string;
    default?: unknown;
}
export interface BaseTypeDefinition extends TypeMetadata {
    type?: TypeSpecifier;
    $extends?: string | string[];
    enum?: unknown[];
    const?: unknown;
}
export interface ObjectTypeDefinition extends BaseTypeDefinition, ObjectValidation {
    type: 'object';
    properties: Record<string, TypeDefinition>;
    required?: string[] | string[][];
    additionalProperties?: boolean | TypeDefinition;
}
export interface ArrayTypeDefinition extends BaseTypeDefinition, ArrayValidation {
    type: 'array';
    items: TypeDefinition;
}
export interface SetTypeDefinition extends BaseTypeDefinition, ArrayValidation {
    type: 'set';
    items: TypeDefinition;
}
export interface MapTypeDefinition extends BaseTypeDefinition, ObjectValidation {
    type: 'map';
    values: TypeDefinition;
}
export interface TupleTypeDefinition extends BaseTypeDefinition {
    type: 'tuple';
    properties: Record<string, TypeDefinition>;
    tuple: string[];
}
export interface ChoiceTypeDefinition extends BaseTypeDefinition {
    type: 'choice';
    choices: Record<string, TypeDefinition>;
    selector?: string;
}
export interface DecimalTypeDefinition extends BaseTypeDefinition, NumericValidation {
    type: 'decimal';
    precision?: number;
    scale?: number;
}
export interface StringTypeDefinition extends BaseTypeDefinition, StringValidation {
    type: 'string';
}
export interface IntegerTypeDefinition extends BaseTypeDefinition, NumericValidation {
    type: IntegerType;
}
export interface FloatTypeDefinition extends BaseTypeDefinition, NumericValidation {
    type: 'float' | 'double';
}
export type TypeDefinition = BaseTypeDefinition | ObjectTypeDefinition | ArrayTypeDefinition | SetTypeDefinition | MapTypeDefinition | TupleTypeDefinition | ChoiceTypeDefinition | DecimalTypeDefinition | StringTypeDefinition | IntegerTypeDefinition | FloatTypeDefinition;
export interface JSONStructureSchema extends BaseTypeDefinition, ObjectValidation {
    $schema: string;
    $id: string;
    name: string;
    $root?: string;
    definitions?: Record<string, TypeDefinition | Namespace>;
    $uses?: string[];
    properties?: Record<string, TypeDefinition>;
    required?: string[] | string[][];
}
export interface Namespace {
    [key: string]: TypeDefinition | Namespace;
}
/** Check if a value is a namespace (contains nested definitions but isn't a type itself) */
export declare function isNamespace(value: unknown): value is Namespace;
/** Check if a value is a type definition */
export declare function isTypeDefinition(value: unknown): value is TypeDefinition;
export declare function isObjectTypeDefinition(def: TypeDefinition): def is ObjectTypeDefinition;
export declare function isArrayTypeDefinition(def: TypeDefinition): def is ArrayTypeDefinition;
export declare function isSetTypeDefinition(def: TypeDefinition): def is SetTypeDefinition;
export declare function isMapTypeDefinition(def: TypeDefinition): def is MapTypeDefinition;
export declare function isTupleTypeDefinition(def: TypeDefinition): def is TupleTypeDefinition;
export declare function isChoiceTypeDefinition(def: TypeDefinition): def is ChoiceTypeDefinition;
export declare function hasEnumValue(def: TypeDefinition): def is TypeDefinition & {
    enum: unknown[];
};
export declare function hasConstValue(def: TypeDefinition): def is TypeDefinition & {
    const: unknown;
};
/** Get the resolved type from a type specifier, handling arrays and references */
export declare function getResolvedType(specifier: TypeSpecifier | undefined): string | string[] | null;
/** Check if a type specifier includes null (making the type nullable) */
export declare function isNullableType(specifier: TypeSpecifier | undefined): boolean;
/** Get non-null types from a type specifier array */
export declare function getNonNullTypes(specifier: TypeSpecifier): TypeKeyword[];
/** Integer type bounds */
export declare const INTEGER_BOUNDS: Record<IntegerType, {
    min: bigint;
    max: bigint;
}>;
