import { StaticAbiType, DynamicAbiType, SchemaAbiType, SchemaAbiTypeToPrimitiveType, DynamicAbiTypeToPrimitiveType, StaticPrimitiveType, DynamicPrimitiveType, StaticAbiTypeToPrimitiveType } from '@latticexyz/schema-type/internal';
import { Hex } from 'viem';
import { AbiParameterToPrimitiveType } from 'abitype';
import { MUDError } from '@latticexyz/common/errors';
import { Table, Schema as Schema$1 } from '@latticexyz/config';

/** @deprecated use `KeySchema` or `ValueSchema` instead */
type Schema = {
    readonly staticFields: readonly StaticAbiType[];
    readonly dynamicFields: readonly DynamicAbiType[];
};
/** @deprecated use `KeySchema` and `ValueSchema` instead */
type TableSchema = {
    readonly keySchema: Schema;
    readonly valueSchema: Schema;
};
type FieldLayout = {
    readonly staticFieldLengths: readonly number[];
    readonly numDynamicFields: number;
};
type UserTypes = Record<string, {
    internalType: SchemaAbiType;
}>;
type KeySchema<userTypes extends UserTypes | undefined = undefined> = Record<string, userTypes extends UserTypes ? StaticAbiType | keyof userTypes : StaticAbiType>;
type ValueSchema<userTypes extends UserTypes | undefined = undefined> = Record<string, userTypes extends UserTypes ? SchemaAbiType | keyof userTypes : SchemaAbiType>;
/** Map a table schema like `{ value: "uint256" }` to its primitive types like `{ value: bigint }` */
type SchemaToPrimitives<TSchema extends ValueSchema> = {
    [key in keyof TSchema]: SchemaAbiTypeToPrimitiveType<TSchema[key]>;
};
type TableRecord<TKeySchema extends KeySchema = KeySchema, TValueSchema extends ValueSchema = ValueSchema> = {
    key: SchemaToPrimitives<TKeySchema>;
    value: SchemaToPrimitives<TValueSchema>;
};
type ValueArgs = {
    staticData: Hex;
    encodedLengths: Hex;
    dynamicData: Hex;
};

declare function abiTypesToSchema(abiTypes: SchemaAbiType[]): Schema;

declare function decodeDynamicField<TAbiType extends DynamicAbiType, TPrimitiveType extends DynamicAbiTypeToPrimitiveType<TAbiType>>(abiType: TAbiType, data: Hex): TPrimitiveType;

declare function decodeField<TAbiType extends SchemaAbiType, TPrimitiveType extends SchemaAbiTypeToPrimitiveType<TAbiType>>(abiType: TAbiType, data: Hex): TPrimitiveType;

declare function decodeKey<TSchema extends KeySchema>(keySchema: TSchema, data: readonly Hex[]): SchemaToPrimitives<TSchema>;

/** @deprecated use `decodeKey` instead */
declare function decodeKeyTuple(keySchema: Schema, keyTuple: readonly Hex[]): StaticPrimitiveType[];

/** @deprecated use `decodeValue` instead */
declare function decodeRecord(valueSchema: Schema, data: Hex): readonly (StaticPrimitiveType | DynamicPrimitiveType)[];

declare function decodeStaticField<TAbiType extends StaticAbiType, TPrimitiveType extends StaticAbiTypeToPrimitiveType<TAbiType>>(abiType: TAbiType, data: Hex): TPrimitiveType;

declare function decodeValue<TSchema extends ValueSchema>(valueSchema: TSchema, data: Hex): SchemaToPrimitives<TSchema>;

declare function decodeValueArgs<TSchema extends ValueSchema>(valueSchema: TSchema, { staticData, encodedLengths, dynamicData }: ValueArgs): SchemaToPrimitives<TSchema>;

declare function encodeField<TSchemaAbiType extends SchemaAbiType>(fieldType: TSchemaAbiType, value: AbiParameterToPrimitiveType<{
    type: TSchemaAbiType;
}>): Hex;

declare function encodeKey<TSchema extends KeySchema>(keySchema: TSchema, key: SchemaToPrimitives<TSchema>): readonly Hex[];

/** @deprecated use `encodeKey` instead */
declare function encodeKeyTuple(keySchema: Schema, keyTuple: StaticPrimitiveType[]): Hex[];

/** @deprecated use `encodeValue` instead */
declare function encodeRecord(valueSchema: Schema, values: readonly (StaticPrimitiveType | DynamicPrimitiveType)[]): Hex;

declare function encodeValue<TSchema extends ValueSchema>(valueSchema: TSchema, value: SchemaToPrimitives<TSchema>): Hex;

declare function encodeValueArgs<TSchema extends ValueSchema>(valueSchema: TSchema, value: SchemaToPrimitives<TSchema>): ValueArgs;

declare class InvalidHexLengthError extends MUDError {
    name: string;
    constructor(value: Hex);
}
declare class InvalidHexLengthForSchemaError extends MUDError {
    name: string;
    constructor(value: Hex);
}
declare class InvalidHexLengthForEncodedLengthsError extends MUDError {
    name: string;
    constructor(value: Hex);
}
declare class InvalidHexLengthForStaticFieldError extends MUDError {
    name: string;
    constructor(abiType: StaticAbiType, value: Hex);
}
declare class InvalidHexLengthForArrayFieldError extends MUDError {
    name: string;
    constructor(abiType: StaticAbiType, value: Hex);
}
declare class SchemaStaticLengthMismatchError extends MUDError {
    name: string;
    constructor(schemaData: Hex, definedLength: number, summedLength: number);
}
declare class EncodedLengthsLengthMismatchError extends MUDError {
    name: string;
    constructor(encodedLengthsData: Hex, definedLength: bigint, summedLength: bigint);
}

/** @deprecated use `valueSchemaToFieldLayoutHex` instead */
declare function fieldLayoutToHex(fieldLayout: FieldLayout): Hex;

declare function hexToEncodedLengths(data: Hex): {
    totalByteLength: bigint;
    fieldByteLengths: readonly number[];
};

declare function hexToSchema(data: Hex): Schema;

declare function hexToTableSchema(data: Hex): TableSchema;

declare function keySchemaToHex(keySchema: KeySchema): Hex;

declare function schemaIndexToAbiType(schema: Schema, schemaIndex: number): SchemaAbiType;

/** @deprecated use `keySchemaToHex` or `valueSchemaToHex` instead */
declare function schemaToHex(schema: Schema): Hex;

declare function staticDataLength(staticFields: readonly StaticAbiType[]): number;

declare function valueSchemaToFieldLayoutHex(valueSchema: ValueSchema): Hex;

declare function valueSchemaToHex(valueSchema: ValueSchema): Hex;

type getKeySchema<table extends Table> = {
    [fieldName in table["key"][number]]: table["schema"][fieldName];
};
declare function getKeySchema<table extends Table>(table: table): getKeySchema<table>;

type getValueSchema<table extends Table> = {
    [fieldName in Exclude<keyof table["schema"], table["key"][number]>]: table["schema"][fieldName];
};
declare function getValueSchema<table extends Table>(table: table): getValueSchema<table>;

type getSchemaTypes<schema extends Schema$1> = {
    readonly [k in keyof schema]: schema[k]["type"];
};
declare function getSchemaTypes<schema extends Schema$1>(schema: schema): getSchemaTypes<schema>;

export { EncodedLengthsLengthMismatchError, FieldLayout, InvalidHexLengthError, InvalidHexLengthForArrayFieldError, InvalidHexLengthForEncodedLengthsError, InvalidHexLengthForSchemaError, InvalidHexLengthForStaticFieldError, KeySchema, Schema, SchemaStaticLengthMismatchError, SchemaToPrimitives, TableRecord, TableSchema, UserTypes, ValueArgs, ValueSchema, abiTypesToSchema, decodeDynamicField, decodeField, decodeKey, decodeKeyTuple, decodeRecord, decodeStaticField, decodeValue, decodeValueArgs, encodeField, encodeKey, encodeKeyTuple, encodeRecord, encodeValue, encodeValueArgs, fieldLayoutToHex, getKeySchema, getSchemaTypes, getValueSchema, hexToEncodedLengths, hexToSchema, hexToTableSchema, keySchemaToHex, schemaIndexToAbiType, schemaToHex, staticDataLength, valueSchemaToFieldLayoutHex, valueSchemaToHex };