import { MaybeBigInt64Array, MaybeBigUint64Array, TypedArray, NdArray } from 'ndarray';
import { StoreApi } from 'zustand';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { PropsWithChildren, ReactNode } from 'react';
import { AxiosInstance } from 'axios';
import { DimensionMapping } from '@h5web/lib';

declare enum H5T_ORDER {
    LE = 0,
    BE = 1,
    VAX = 2,
    MIXED = 3,
    NONE = 4
}
declare enum H5T_CSET {
    ASCII = 0,
    UTF8 = 1
}
declare enum H5T_STR {
    NULLTERM = 0,
    NULLPAD = 1,
    SPACEPAD = 2
}
declare const H5T_TO_ENDIANNESS: {
    readonly 0: "little-endian";
    readonly 1: "big-endian";
    readonly 2: "VAX";
    readonly 3: "mixed";
    readonly 4: "none";
};
declare const H5T_TO_CHAR_SET: {
    readonly 0: "ASCII";
    readonly 1: "UTF-8";
};
declare const H5T_TO_STR_PAD: {
    readonly 0: "null-terminated";
    readonly 1: "null-padded";
    readonly 2: "space-padded";
};

type NumArray = TypedArray | number[];
type BigIntTypedArray = MaybeBigInt64Array | MaybeBigUint64Array;
type ExportFormat = 'json' | 'csv' | 'npy' | 'tiff';
type ExportURL = URL | (() => Promise<URL | Blob>);
type BuiltInExporter = () => string;

declare enum EntityKind {
    Group = "group",
    Dataset = "dataset",
    Datatype = "datatype",
    Unresolved = "unresolved"
}
interface Entity {
    name: string;
    path: string;
    kind: EntityKind;
    attributes: Attribute[];
    link?: Link;
}
type ProvidedEntity = GroupWithChildren | Dataset | Datatype | UnresolvedEntity;
type ChildEntity = Group | Dataset | Datatype | UnresolvedEntity;
interface Group extends Entity {
    kind: EntityKind.Group;
}
interface GroupWithChildren extends Group {
    children: ChildEntity[];
}
interface Dataset<S extends Shape = Shape, T extends DType = DType> extends Entity {
    kind: EntityKind.Dataset;
    shape: S;
    type: T;
    rawType?: unknown;
    chunks?: number[];
    filters?: Filter[];
    virtualSources?: VirtualSource[];
}
interface Datatype<T = DType> extends Entity {
    kind: EntityKind.Datatype;
    type?: T;
    rawType?: unknown;
}
interface UnresolvedEntity extends Entity {
    kind: EntityKind.Unresolved;
}
type LinkClass = 'Hard' | 'Soft' | 'External';
interface Link {
    class: LinkClass;
    file?: string;
    path?: string;
}
interface Attribute<S extends Shape = Shape, T extends DType = DType> {
    name: string;
    shape: S;
    type: T;
}
interface Filter {
    id: number;
    name: string;
}
interface VirtualSource {
    file: string;
    path: string;
}
interface DatasetDef<SC extends ShapeClass = ShapeClass, DTC extends DTypeClass = DTypeClass> {
    path: string;
    shape?: SC;
    type?: DTC;
}
type DatasetFromDef<D extends DatasetDef> = Dataset<NonNullable<D['shape']> extends ShapeClass ? ShapeClassMap[NonNullable<D['shape']>] : Shape, NonNullable<D['type']> extends DTypeClass ? DTypeClassMap[NonNullable<D['type']>] : DType>;
declare enum ShapeClass {
    Array = "Array",
    Scalar = "Scalar",
    Null = "Null"
}
interface ShapeClassMap {
    [ShapeClass.Array]: ArrayShape;
    [ShapeClass.Scalar]: ScalarShape;
    [ShapeClass.Null]: NullShape;
}
type Shape = ArrayShape | ScalarShape | NullShape;
interface ArrayShape {
    class: ShapeClass.Array;
    dims: number[];
}
interface ScalarShape {
    class: ShapeClass.Scalar;
    dims: [];
}
interface NullShape {
    class: ShapeClass.Null;
}
interface HasShape<S extends Shape = Shape> {
    shape: S;
}
declare enum DTypeClass {
    Bool = "Boolean",
    Integer = "Integer",
    Float = "Float",
    Complex = "Complex",
    String = "String",
    Compound = "Compound",
    Array = "Array",
    VLen = "Array (variable length)",
    Enum = "Enumeration",
    Time = "Time",
    Bitfield = "Bitfield",
    Opaque = "Opaque",
    Reference = "Reference",
    Unknown = "Unknown"
}
interface DTypeClassMap {
    [DTypeClass.Bool]: BooleanType;
    [DTypeClass.Integer]: IntegerType;
    [DTypeClass.Float]: FloatType;
    [DTypeClass.Complex]: ComplexType;
    [DTypeClass.String]: StringType;
    [DTypeClass.Compound]: CompoundType;
    [DTypeClass.Array]: ArrayType;
    [DTypeClass.VLen]: VLenType;
    [DTypeClass.Enum]: EnumType;
    [DTypeClass.Time]: TimeType;
    [DTypeClass.Bitfield]: BitfieldType;
    [DTypeClass.Opaque]: OpaqueType;
    [DTypeClass.Reference]: ReferenceType;
    [DTypeClass.Unknown]: UnknownType;
}
type Endianness = (typeof H5T_TO_ENDIANNESS)[H5T_ORDER];
type CharSet = (typeof H5T_TO_CHAR_SET)[H5T_CSET];
type StrPad = (typeof H5T_TO_STR_PAD)[H5T_STR];
type NumericType = IntegerType | FloatType;
type NumericLikeType = NumericType | BooleanType | EnumType;
type PrintableType = StringType | NumericLikeType | ComplexType;
type DType = PrintableType | CompoundType | ArrayType | VLenType | TimeType | BitfieldType | OpaqueType | ReferenceType | UnknownType;
interface IntegerType {
    class: DTypeClass.Integer;
    signed: boolean;
    size: number;
    endianness: Endianness | undefined;
}
interface FloatType {
    class: DTypeClass.Float;
    size: number;
    endianness: Endianness | undefined;
}
interface ComplexType {
    class: DTypeClass.Complex;
    realType: NumericType;
    imagType: NumericType;
}
interface StringType {
    class: DTypeClass.String;
    charSet: CharSet | undefined;
    strPad: StrPad | undefined;
    length?: number;
}
interface CompoundType<T extends DType = DType> {
    class: DTypeClass.Compound;
    fields: Map<string, T>;
}
interface ArrayType<T extends DType = DType> {
    class: DTypeClass.Array;
    base: T;
    dims: number[];
}
interface VLenType<T extends DType = DType> {
    class: DTypeClass.VLen;
    base: T;
}
interface BooleanType {
    class: DTypeClass.Bool;
    base: NumericType;
}
interface EnumType {
    class: DTypeClass.Enum;
    base: NumericType;
    mapping: Record<number, string>;
}
interface TimeType {
    class: DTypeClass.Time;
}
interface BitfieldType {
    class: DTypeClass.Bitfield;
    endianness: Endianness | undefined;
}
interface ReferenceType {
    class: DTypeClass.Reference;
}
interface OpaqueType {
    class: DTypeClass.Opaque;
    tag: string;
}
interface UnknownType {
    class: DTypeClass.Unknown;
}
interface HasType<T extends DType = DType> {
    type: T;
}
type ScalarValue<T extends DType = DType> = T extends NumericLikeType ? number | (T extends IntegerType ? bigint : never) | (T extends BooleanType ? boolean : never) : T extends StringType ? string : T extends ComplexType ? H5WebComplex : T extends CompoundType<infer TFields> ? ScalarValue<TFields>[] : unknown;
type ArrayValue<T extends DType = DType> = T extends NumericLikeType ? TypedArray | number[] | (T extends IntegerType ? BigIntTypedArray | bigint[] : never) | (T extends BooleanType ? boolean[] : never) : ScalarValue<T>[];
type Value<D extends HasShape & HasType> = D extends HasShape<infer S> & HasType<infer T> ? S extends ScalarShape ? ScalarValue<T> : S extends ArrayShape ? ArrayValue<T> : never : never;
type AttributeValues = Record<string, unknown>;
type H5WebComplex = [real: number, imag: number];

type OnProgress = (value: number) => void;
interface FetchStore<Input, Result> {
    has: (input: Input) => boolean;
    prefetch: (input: Input) => void;
    get: (input: Input) => Result;
    preset: (input: Input, result: Result) => void;
    evict: (input: Input) => void;
    evictErrors: () => void;
    abort: (input: Input, reason?: string, evict?: boolean) => void;
    abortAll: (reason?: string, evict?: boolean) => void;
    get progressStore(): StoreApi<ProgressState<Input>>;
}
interface ProgressState<Input> {
    ongoing: Map<Input, number | undefined>;
    setProgress: (input: Input, value?: number) => void;
    clearProgress: (input: Input) => void;
}
declare class AbortError extends Error {
    constructor(reason?: string);
}

type EntitiesStore = FetchStore<string, ProvidedEntity>;
type ValuesStore = FetchStore<ValuesStoreParams, unknown>;
type AttrValuesStore = FetchStore<Entity, AttributeValues>;
interface ValuesStoreParams {
    dataset: Dataset<ScalarShape | ArrayShape>;
    selection?: string | undefined;
}
type Fetcher = (url: string, params: Record<string, string>, opts?: FetcherOptions) => Promise<ArrayBuffer>;
interface FetcherOptions {
    abortSignal?: AbortSignal;
    onProgress?: OnProgress;
}

declare abstract class DataProviderApi {
    readonly filepath: string;
    constructor(filepath: string);
    abstract getEntity(path: string): Promise<ProvidedEntity>;
    abstract getValue(params: ValuesStoreParams, abortSignal?: AbortSignal, onProgress?: OnProgress): Promise<unknown>;
    abstract getAttrValues(entity: Entity): Promise<AttributeValues>;
    getExportURL?(format: ExportFormat, dataset: Dataset, selection?: string, builtInExporter?: BuiltInExporter): ExportURL | undefined;
    getSearchablePaths?(path: string): Promise<string[]>;
}

interface FeedbackContext {
    filePath: string;
    entityPath: string;
}

interface Props$5 {
    sidebarOpen?: boolean;
    initialPath?: string;
    getFeedbackURL?: (context: FeedbackContext) => string;
    disableDarkMode?: boolean;
    propagateErrors?: boolean;
}
declare function App(props: Props$5): react_jsx_runtime.JSX.Element;

interface Props$4 {
    getExportURL?: DataProviderApi['getExportURL'];
}
declare function MockProvider(props: PropsWithChildren<Props$4>): react_jsx_runtime.JSX.Element;

interface Props$3 {
    url: string;
    filepath: string;
    resetKeys?: unknown[];
    fetcher: Fetcher;
    getExportURL?: DataProviderApi['getExportURL'];
}
declare function HsdsProvider(props: PropsWithChildren<Props$3>): react_jsx_runtime.JSX.Element;

interface Props$2 {
    url: string;
    filepath: string;
    resetKeys?: unknown[];
    fetcher?: Fetcher;
    getExportURL?: DataProviderApi['getExportURL'];
}
declare function H5GroveProvider(props: PropsWithChildren<Props$2>): react_jsx_runtime.JSX.Element;

declare function getValueOrError(api: DataProviderApi, dataset: Dataset<ArrayShape | ScalarShape>): Promise<unknown>;
declare function createBasicFetcher(fetchOpts?: Omit<RequestInit, 'signal'>): Fetcher;
declare function createAxiosFetcher(axiosInstance: AxiosInstance): Fetcher;
declare function buildBasicAuthHeader(username: string, password: string): Record<string, string>;

declare function hasAttribute(entity: Entity, attributeName: string): boolean;
declare function findAttribute(entity: Entity, attributeName: string): Attribute | undefined;
declare function findScalarNumAttr(entity: Entity, attributeName: string): Attribute<ScalarShape, NumericType> | undefined;
declare function findScalarStrAttr(entity: Entity, attributeName: string): Attribute<ScalarShape, StringType> | undefined;
declare function getAttributeValue<A extends Attribute<ScalarShape | ArrayShape>>(entity: Entity, attribute: A, attrValuesStore: AttrValuesStore): Value<A>;
declare function getAttributeValue<A extends Attribute<ScalarShape | ArrayShape>>(entity: Entity, attribute: A | undefined, attrValuesStore: AttrValuesStore): Value<A> | undefined;
declare function enableBigIntSerialization(): void;

declare function getFeedbackMailto(context: FeedbackContext, email: string, subject?: string): string;

interface DataContextValue {
    filepath: string;
    filename: string;
    entitiesStore: EntitiesStore;
    valuesStore: ValuesStore;
    attrValuesStore: AttrValuesStore;
    getExportURL?: DataProviderApi['getExportURL'];
    getSearchablePaths?: DataProviderApi['getSearchablePaths'];
}
declare function useDataContext(): DataContextValue;
interface Props$1 {
    api: DataProviderApi;
}
declare function DataProvider(props: PropsWithChildren<Props$1>): react_jsx_runtime.JSX.Element;

declare function useEntity(path: string): ProvidedEntity;
declare function useDatasets<R extends Record<string, DatasetDef>>(defs: R): {
    [K in keyof R]: DatasetFromDef<R[K]>;
};
declare function useValue<D extends Dataset<ArrayShape | ScalarShape>>(dataset: D, selection?: string): Value<D>;
declare function useValue<D extends Dataset<ArrayShape | ScalarShape>>(dataset: D | undefined, selection?: string): Value<D> | undefined;
type ValueFromParams<T extends ValuesStoreParams['dataset'] | ValuesStoreParams> = Value<T extends ValuesStoreParams ? T['dataset'] : T>;
declare function useValues<R extends Record<string, ValuesStoreParams['dataset'] | ValuesStoreParams>>(datasets: R): {
    [K in keyof R]: ValueFromParams<R[K]>;
};
declare function useValuesInCache(...datasets: (Dataset<ScalarShape | ArrayShape> | undefined)[]): (dimMapping: DimensionMapping) => boolean;

declare function getBaseArray<T extends ArrayValue | undefined>(value: T, rawDims: number[]): T extends ArrayValue ? NdArray<T> : undefined;
declare function applyMapping<T extends NdArray<ArrayValue> | undefined>(baseArray: T, mapping: DimensionMapping): T extends NdArray<ArrayValue> ? T : undefined;
declare function toNumArray<T extends ArrayValue<NumericLikeType> | undefined>(arr: T): T extends ArrayValue<NumericLikeType> ? NumArray : undefined;

declare const useToNumArray: typeof toNumArray;
declare function useToNumArrays(arrays: ArrayValue<NumericLikeType>[]): NumArray[];
declare function useToNumArrays(arrays: (ArrayValue<NumericLikeType> | undefined)[]): (NumArray | undefined)[];
declare function useBaseArray<T extends ArrayValue | undefined>(value: T, rawDims: number[]): T extends ArrayValue ? NdArray<T> : undefined;
declare function useMappedArray<T extends ArrayValue | undefined>(value: T, dims: number[], mapping: DimensionMapping): T extends ArrayValue ? NdArray<T> : undefined;
declare function useMappedArrays<T extends ArrayValue>(values: T[], dims: number[], mapping: DimensionMapping): NdArray<T>[];
declare function useMappedArrays<T extends ArrayValue>(values: (T | undefined)[], dims: number[], mapping: DimensionMapping): (NdArray<T> | undefined)[];

declare function isDefined<T>(val: T): val is T extends undefined ? never : T;
declare function isNonNull<T>(val: T): val is T extends null ? never : T;
declare function assertDefined<T>(val: T, message?: string): asserts val is T extends undefined ? never : T;
declare function assertNonNull<T>(val: T, message?: string): asserts val is T extends null ? never : T;
declare function assertNum(val: unknown, message?: string): asserts val is number;
declare function assertStr(val: unknown, message?: string): asserts val is string;
declare function assertEnvVar(val: unknown, name: string): asserts val is string;
declare function assertComplex(val: unknown, message?: string): asserts val is H5WebComplex;
declare function assertArray(val: unknown, message?: string): asserts val is unknown[];
declare function isTypedArray(val: unknown): val is TypedArray;
declare function isBigIntTypedArray(val: unknown): val is BigIntTypedArray;
declare function assertTypedArray(val: unknown, message?: string): asserts val is TypedArray;
declare function assertBigIntTypedArray(val: unknown, message?: string): asserts val is BigIntTypedArray;
declare function assertArrayOrTypedArray(val: unknown, message?: string): asserts val is unknown[] | TypedArray;
declare function assertAnyTypedArray(val: unknown, message?: string): asserts val is TypedArray | BigIntTypedArray;
declare function assertArrayOrAnyTypedArray(val: unknown, message?: string): asserts val is unknown[] | TypedArray | BigIntTypedArray;
declare function isGroup(entity: Entity): entity is Group;
declare function assertGroup(entity: Entity, message?: string): asserts entity is Group;
declare function hasChildren(group: Group): group is GroupWithChildren;
declare function assertGroupWithChildren(group: Group, message?: string): asserts group is GroupWithChildren;
declare function isDataset(entity: Entity): entity is Dataset;
declare function assertDataset(entity: Entity, message?: string): asserts entity is Dataset;
declare function isDatatype(entity: Entity): entity is Datatype;
declare function assertDatatype(entity: Entity, message?: string): asserts entity is Datatype;
declare function isShape<C extends ShapeClass>(shape: Shape, shapeClass: C): shape is ShapeClassMap[C];
declare function hasShape<O extends HasShape, C extends ShapeClass>(obj: O, shapeClass: C): obj is O & HasShape<ShapeClassMap[C]>;
declare function assertShape<O extends HasShape, C extends ShapeClass>(obj: O, shapeClass: C, message?: string): asserts obj is O & ShapeClassMap[C];
declare function isScalarShape(shape: Shape): shape is ScalarShape;
declare function hasScalarShape<O extends HasShape>(obj: O): obj is O & HasShape<ScalarShape>;
declare function assertScalarShape<O extends HasShape>(obj: O, message?: string): asserts obj is O & HasShape<ScalarShape>;
declare function isArrayShape(shape: Shape): shape is ArrayShape;
declare function hasArrayShape<O extends HasShape>(obj: O): obj is O & HasShape<ArrayShape>;
declare function assertArrayShape<O extends HasShape>(obj: O, message?: string): asserts obj is O & HasShape<ArrayShape>;
declare function isNonNullShape(shape: Shape): shape is ScalarShape | ArrayShape;
declare function hasNonNullShape<O extends HasShape>(obj: O): obj is O & HasShape<ScalarShape | ArrayShape>;
declare function assertNonNullShape<O extends HasShape>(obj: O, message?: string): asserts obj is O & HasShape<ScalarShape | ArrayShape>;
declare function hasMinDims(obj: HasShape<ArrayShape>, min: number): boolean;
declare function assertMinDims(obj: HasShape<ArrayShape>, min: number, message?: string): void;
declare function hasNumDims(obj: HasShape<ArrayShape>, num: number): boolean;
declare function assertNumDims(obj: HasShape<ArrayShape>, num: number, message?: string): void;
declare function isType<C extends DTypeClass>(type: DType, dtypeClass: C): type is DTypeClassMap[C];
declare function hasType<O extends HasType, C extends DTypeClass>(obj: O, dtypeClass: C): obj is O & HasType<DTypeClassMap[C]>;
declare function assertType<O extends HasType, C extends DTypeClass>(obj: O, dtypeClass: C, message?: string): asserts obj is O & DTypeClassMap[C];
declare function isStringType(type: DType): type is StringType;
declare function hasStringType<O extends HasType>(obj: O): obj is O & HasType<StringType>;
declare function assertStringType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<StringType>;
declare function isIntegerType(type: DType): type is IntegerType;
declare function isFloatType(type: DType): type is FloatType;
declare function isNumericType(type: DType): type is NumericType;
declare function hasIntegerType<O extends HasType>(obj: O): obj is O & HasType<IntegerType>;
declare function hasFloatType<O extends HasType>(obj: O): obj is O & HasType<FloatType>;
declare function hasNumericType<O extends HasType>(obj: O): obj is O & HasType<NumericType>;
declare function assertIntegerType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<IntegerType>;
declare function assertFloatType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<FloatType>;
declare function assertNumericType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<NumericType>;
declare function isBoolType(type: DType): type is BooleanType;
declare function isEnumType(type: DType): type is EnumType;
declare function isNumericLikeType(type: DType): type is NumericLikeType;
declare function hasBoolType<O extends HasType>(obj: O): obj is O & HasType<BooleanType>;
declare function hasEnumType<O extends HasType>(obj: O): obj is O & HasType<EnumType>;
declare function hasNumericLikeType<O extends HasType>(obj: O): obj is O & HasType<NumericLikeType>;
declare function assertBoolType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<BooleanType>;
declare function assertEnumType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<EnumType>;
declare function assertNumericLikeType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<NumericLikeType>;
declare function isComplexType(type: DType): type is ComplexType;
declare function hasComplexType<O extends HasType>(obj: O): obj is O & HasType<ComplexType>;
declare function assertComplexType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<ComplexType>;
declare function assertNumericLikeOrComplexType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<NumericLikeType | ComplexType>;
declare function isPrintableType(type: DType): type is PrintableType;
declare function hasPrintableType<O extends HasType>(obj: O): obj is O & HasType<PrintableType>;
declare function assertPrintableType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<PrintableType>;
declare function isCompoundType(type: DType): type is CompoundType;
declare function hasCompoundType<O extends HasType>(obj: O): obj is O & HasType<CompoundType>;
declare function assertCompoundType<O extends HasType>(obj: O, message?: string): asserts obj is O & HasType<CompoundType>;
declare function isArrayOrVlenType(type: DType): type is ArrayType | VLenType;
declare function assertScalarValue<T extends DType>(value: unknown, type: T): asserts value is ScalarValue<T>;
declare function assertValue<O extends HasShape<ArrayShape | ScalarShape> & HasType>(value: unknown, obj: O): asserts value is Value<O>;

declare function arrayDef<T extends DTypeClass>(path: string, type: T): DatasetDef<ShapeClass.Array, T>;
declare function scalarDef<T extends DTypeClass>(path: string, type: T): DatasetDef<ShapeClass.Scalar, T>;
declare function parseShape(dims: number[] | null | undefined): Shape;

interface Props<D extends Dataset> {
    dataset: D;
    selection?: string;
    render: (val: Value<D>) => ReactNode;
}
declare function ValueFetcher<D extends Dataset<ArrayShape | ScalarShape>>(props: Props<D>): ReactNode;

type GetExportURL = NonNullable<DataProviderApi['getExportURL']>;

export { AbortError, App, DTypeClass, DataProvider, DataProviderApi, EntityKind, H5GroveProvider, HsdsProvider, MockProvider, ShapeClass, ValueFetcher, applyMapping, arrayDef, assertAnyTypedArray, assertArray, assertArrayOrAnyTypedArray, assertArrayOrTypedArray, assertArrayShape, assertBigIntTypedArray, assertBoolType, assertComplex, assertComplexType, assertCompoundType, assertDataset, assertDatatype, assertDefined, assertEnumType, assertEnvVar, assertFloatType, assertGroup, assertGroupWithChildren, assertIntegerType, assertMinDims, assertNonNull, assertNonNullShape, assertNum, assertNumDims, assertNumericLikeOrComplexType, assertNumericLikeType, assertNumericType, assertPrintableType, assertScalarShape, assertScalarValue, assertShape, assertStr, assertStringType, assertType, assertTypedArray, assertValue, buildBasicAuthHeader, createAxiosFetcher, createBasicFetcher, enableBigIntSerialization, findAttribute, findScalarNumAttr, findScalarStrAttr, getAttributeValue, getBaseArray, getFeedbackMailto, getValueOrError, hasArrayShape, hasAttribute, hasBoolType, hasChildren, hasComplexType, hasCompoundType, hasEnumType, hasFloatType, hasIntegerType, hasMinDims, hasNonNullShape, hasNumDims, hasNumericLikeType, hasNumericType, hasPrintableType, hasScalarShape, hasShape, hasStringType, hasType, isArrayOrVlenType, isArrayShape, isBigIntTypedArray, isBoolType, isComplexType, isCompoundType, isDataset, isDatatype, isDefined, isEnumType, isFloatType, isGroup, isIntegerType, isNonNull, isNonNullShape, isNumericLikeType, isNumericType, isPrintableType, isScalarShape, isShape, isStringType, isType, isTypedArray, parseShape, scalarDef, toNumArray, useBaseArray, useDataContext, useDatasets, useEntity, useMappedArray, useMappedArrays, useBaseArray as useNdArray, useToNumArray, useToNumArrays, useValue, useValues, useValuesInCache };
export type { ArrayShape, ArrayType, ArrayValue, AttrValuesStore, Attribute, AttributeValues, BitfieldType, BooleanType, BuiltInExporter, ChildEntity, ComplexType, CompoundType, DType, DataContextValue, Dataset, DatasetDef, Datatype, EntitiesStore, Entity, EnumType, ExportFormat, ExportURL, FeedbackContext, Fetcher, FetcherOptions, Filter, FloatType, GetExportURL, Group, GroupWithChildren, H5WebComplex, IntegerType, LinkClass, NumArray, NumericLikeType, NumericType, OpaqueType, PrintableType, ProvidedEntity, ReferenceType, ScalarShape, ScalarValue, Shape, StringType, TimeType, UnknownType, UnresolvedEntity, VLenType, Value, ValuesStore, ValuesStoreParams, VirtualSource };