interface WebMetalRenderingContext {
    createCommandQueue(): WebMetalCommandQueue;
    createBuffer(data: ArrayBufferView): WebMetalBuffer;
    createLibrary(sourceCode: string): WebMetalLibrary;
    createComputePipelineState(function_: WebMetalFunction): WebMetalComputePipelineState;
}
interface WebMetalFunction {
}
interface WebMetalLibrary {
    functionNames: string[];
    functionWithName(name: string): WebMetalFunction;
}
interface WebMetalBuffer {
    contents: any;
}
interface WebMetalSize {
    width: number;
    height: number;
    depth: number;
}
interface WebMetalCommandQueue {
    createCommandBuffer(): WebMetalCommandBuffer;
}
interface WebMetalCommandBuffer {
    createComputeCommandEncoder(): WebMetalComputeCommandEncoder;
    commit(): void;
    completed: Promise<void>;
}
interface WebMetalCommandEncoder {
    endEncoding(): void;
}
interface WebMetalComputeCommandEncoder extends WebMetalCommandEncoder {
    setComputePipelineState(state: WebMetalComputePipelineState): void;
    setBuffer(buffer: WebMetalBuffer, offset: number, index: number): void;
    dispatch(threadgroupsPerGrid: WebMetalSize, threadsPerThreadgroup: WebMetalSize): void;
}
interface WebMetalComputePipelineState {
}
interface HTMLCanvasElement {
    getContext(contextId: "webmetal"): WebMetalRenderingContext | null;
}
declare module 'webdnn/placeholder' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	/**
	 * @protected
	 */
	export interface Placeholder {
	    eval: string;
	}
	/**
	 * PlaceholderContext manages the placeholders
	 * @protected
	 */
	export default class PlaceholderContext {
	    private values;
	    constructor(values?: {
	        [key: string]: number | null;
	    });
	    readonly isResolved: boolean;
	    update(values: {
	        [key: string]: number | null;
	    }): void;
	    resolve(placeholder: any): any;
	    toString(): string;
	}

}
declare module 'webdnn/graph_descriptor/memory_layout' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { Placeholder } from 'webdnn/placeholder';
	/**
	 * @protected
	 */
	export interface Allocation {
	    name: string;
	    offset: number | Placeholder;
	    size: number | Placeholder;
	}
	/**
	 * @protected
	 */
	export interface ResolvedAllocation extends Allocation {
	    offset: number;
	    size: number;
	}
	/**
	 * @protected
	 */
	export interface MemoryLayout {
	    'static': {
	        size: number;
	        allocations: {
	            [index: string]: ResolvedAllocation;
	        };
	    };
	    dynamic: {
	        size: number | Placeholder;
	        allocations: {
	            [index: string]: Allocation;
	        };
	    };
	}

}
declare module 'webdnn/graph_descriptor/graph_descriptor' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { MemoryLayout } from 'webdnn/graph_descriptor/memory_layout';
	/**
	 * Graph Descriptor
	 * @protected
	 */
	export interface GraphDescriptor {
	    /**
	     * Unix timestamp when this graph descriptor is generated
	     */
	    converted_at: number;
	    /**
	     * input variables' name
	     */
	    inputs: string[];
	    /**
	     * output variables' name
	     */
	    outputs: string[];
	    /**
	     * memory position table
	     */
	    memory_layout: MemoryLayout;
	    /**
	     * Encoding algorithm of weight binary data.
	     */
	    weight_encoding: string;
	    /**
	     * Placeholder dict
	     */
	    placeholders: {
	        [key: string]: number;
	    };
	}

}
declare module 'webdnn/symbolic_typed_array/symbolic_typed_array' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import PlaceholderContext, { Placeholder } from 'webdnn/placeholder';
	/**
	 * @protected
	 */
	export abstract class SymbolicTypedArray<T extends Float32Array | Int32Array> {
	    protected placeholderContext: PlaceholderContext | null;
	    /**
	     * @protected
	     */
	    readonly _length: number | Placeholder;
	    /**
	     * @protected
	     */
	    readonly _byteOffset: number | Placeholder;
	    /**
	     * The size in bytes of each element in the array.
	     */
	    readonly BYTES_PER_ELEMENT: number;
	    /**
	     * @protected
	     */
	    protected _buffer: ArrayBufferLike | null;
	    /**
	     * @protected
	     */
	    name: string;
	    /**
	     * @protected
	     */
	    constructor(buffer?: ArrayBufferLike | null, byteOffset?: number | Placeholder, length?: number | Placeholder, placeholderContext?: PlaceholderContext | null);
	    /**
	     * Convert SymbolicTypedArray instance into actual TypedArray instance.
	     *
	     * @returns actual typed array
	     */
	    abstract toActual(): T;
	    /**
	     * The ArrayBuffer instance referenced by the array.
	     */
	    /**
	    * The ArrayBuffer instance referenced by the array.
	    */
	    buffer: ArrayBufferLike;
	    /**
	     * The length in bytes of the array.
	     */
	    readonly byteLength: number;
	    /**
	     * The number in this buffer. Actual offset size is `(offset * SIZE_OF_FLOAT)`.
	     */
	    readonly offset: number;
	    /**
	     * @protected
	     */
	    readonly isDynamic: boolean;
	    /**
	     * The number of elements in this buffer. Actual byte size is `(length * SIZE_OF_FLOAT)`.
	     */
	    readonly length: number;
	    /**
	     * The offset in bytes of the array.
	     */
	    readonly byteOffset: any;
	    /**
	     * Returns the this object after copying a section of the array identified by start and end
	     * to the same array starting at position target
	     * @param target If target is negative, it is treated as length+target where length is the
	     * length of the array.
	     * @param start If start is negative, it is treated as length+start. If end is negative, it
	     * is treated as length+end.
	     * @param end If not specified, length of the this object is used as its default value.
	     */
	    copyWithin(target: number, start: number, end?: number): this;
	    /**
	     * Returns the this object after filling the section identified by start and end with value
	     * @param value value to fill array section with
	     * @param start index to start filling the array at. If start is negative, it is treated as
	     * length+start where length is the length of the array.
	     * @param end index to stop filling the array at. If end is negative, it is treated as
	     * length+end.
	     */
	    fill(value: number, start?: number, end?: number): this;
	    /**
	     * Returns the index of the first occurrence of a value in an array.
	     * @param searchElement The value to locate in the array.
	     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
	     *  search starts at index 0.
	     */
	    indexOf(searchElement: number, fromIndex?: number): number;
	    /**
	     * Adds all the elements of an array separated by the specified separator string.
	     * @param separator A string used to separate one element of an array from the next in the
	     * resulting String. If omitted, the array elements are separated with a comma.
	     */
	    join(separator?: string): string;
	    /**
	     * Returns the index of the last occurrence of a value in an array.
	     * @param searchElement The value to locate in the array.
	     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
	     * search starts at index 0.
	     */
	    lastIndexOf(searchElement: number, fromIndex?: number): number;
	    /**
	     * Sorts an array.
	     * @param compareFn The name of the function used to determine the order of the elements. If
	     * omitted, the elements are sorted in ascending, ASCII character order.
	     */
	    sort(compareFn?: (a: number, b: number) => number): this;
	    includes(searchElement: number, fromIndex?: number | undefined): boolean;
	    /**
	     * Sets a value or an array of values.
	     * @param array A typed or untyped array of values to set.
	     * @param offset The index in the current array at which the values are to be written.
	     */
	    set(array: ArrayLike<number>, offset?: number | undefined): void;
	    /**
	     * Converts a number to a string by using the current locale.
	     */
	    toLocaleString(): string;
	    /**
	     * Returns a string representation of an array.
	     */
	    toString(): string;
	    /** @protected */
	    [Symbol.iterator](): IterableIterator<number>;
	    /**
	     * Returns an iterable of key, value pairs for every entry in the array
	     */
	    entries(): IterableIterator<[number, number]>;
	    /**
	     * Returns an iterable of keys in the array
	     */
	    keys(): IterableIterator<number>;
	    /**
	     * Returns an iterable of values in the array
	     */
	    values(): IterableIterator<number>;
	}

}
declare module 'webdnn/symbolic_typed_array/symbolic_float32array' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { SymbolicTypedArray } from 'webdnn/symbolic_typed_array/symbolic_typed_array';
	/**
	 * Typed array used for input and output variables of [[webdnn.DescriptorRunner| `DescriptorRunner`]].
	 * You can use `SymbolicFloat32Array` almost as same as `Float32Array`.
	 *
	 * To convert `SymbolicFloat32Array` into actual `Float32Array`, use [[webdnn.SymbolicFloat32Array.toActual| `toActual()`]]
	 *
	 * ```js
	 *
	 * let result = runner.outputs[0];  //runner.outputs is array of SymbolicFloat32Array
	 *
	 * // SymbolicFloat32Array does NOT support index access
	 * console.log(result[0]);
	 * >>> undefined
	 *
	 * // By conversion, you can access each element by index
	 * console.log(result.toActual()[0]);
	 * >>> 1.00  // Actual result
	 * ```
	 */
	export default class SymbolicFloat32Array extends SymbolicTypedArray<Float32Array> implements Float32Array {
	    /** @protected */
	    [Symbol.toStringTag]: "Float32Array";
	    /** @protected */
	    [index: number]: number;
	    /**
	     * The size in bytes of each element in SymbolicFloat32Array.
	     */
	    static readonly BYTES_PER_ELEMENT: number;
	    /**
	     * The size in bytes of each element in the array.
	     */
	    readonly BYTES_PER_ELEMENT: number;
	    /**
	     * Convert SymbolicTypedArray instance into actual TypedArray instance.
	     *
	     * @returns actual typed array
	     */
	    toActual(): Float32Array;
	    /**
	     * Determines whether all the members of an array satisfy the specified test.
	     * @param callbackfn A function that accepts up to three arguments. The every method calls
	     * the callbackfn function for each element in array1 until the callbackfn returns false,
	     * or until the end of the array.
	     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
	     * If thisArg is omitted, undefined is used as the this value.
	     */
	    every(callbackfn: (value: number, index: number, array: Float32Array) => boolean, thisArg?: any): boolean;
	    /**
	     * Returns the elements of an array that meet the condition specified in a callback function.
	     * @param callbackfn A function that accepts up to three arguments. The filter method calls
	     * the callbackfn function one time for each element in the array.
	     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
	     * If thisArg is omitted, undefined is used as the this value.
	     */
	    filter(callbackfn: (value: number, index: number, array: Float32Array) => any, thisArg?: any): Float32Array;
	    /**
	     * Returns the value of the first element in the array where predicate is true, and undefined
	     * otherwise.
	     * @param predicate find calls predicate once for each element of the array, in ascending
	     * order, until it finds one where predicate returns true. If such an element is found, find
	     * immediately returns that element value. Otherwise, find returns undefined.
	     * @param thisArg If provided, it will be used as the this value for each invocation of
	     * predicate. If it is not provided, undefined is used instead.
	     */
	    find(predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number | undefined;
	    /**
	     * Returns the index of the first element in the array where predicate is true, and -1
	     * otherwise.
	     * @param predicate find calls predicate once for each element of the array, in ascending
	     * order, until it finds one where predicate returns true. If such an element is found,
	     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
	     * @param thisArg If provided, it will be used as the this value for each invocation of
	     * predicate. If it is not provided, undefined is used instead.
	     */
	    findIndex(predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number;
	    /**
	     * Performs the specified action for each element in an array.
	     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
	     * callbackfn function one time for each element in the array.
	     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
	     * If thisArg is omitted, undefined is used as the this value.
	     */
	    forEach(callbackfn: (value: number, index: number, array: Float32Array) => void, thisArg?: any): void;
	    /**
	     * Calls a defined callback function on each element of an array, and returns an array that
	     * contains the results.
	     * @param callbackfn A function that accepts up to three arguments. The map method calls the
	     * callbackfn function one time for each element in the array.
	     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
	     * If thisArg is omitted, undefined is used as the this value.
	     */
	    map(callbackfn: (value: number, index: number, array: Float32Array) => number, thisArg?: any): Float32Array;
	    /**
	     * Calls the specified callback function for all the elements in an array. The return value of
	     * the callback function is the accumulated result, and is provided as an argument in the next
	     * call to the callback function.
	     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
	     * callbackfn function one time for each element in the array.
	     * @param initialValue If initialValue is specified, it is used as the initial value to start
	     * the accumulation. The first call to the callbackfn function provides this value as an argument
	     * instead of an array value.
	     */
	    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number;
	    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number;
	    /**
	     * Calls the specified callback function for all the elements in an array. The return value of
	     * the callback function is the accumulated result, and is provided as an argument in the next
	     * call to the callback function.
	     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
	     * callbackfn function one time for each element in the array.
	     * @param initialValue If initialValue is specified, it is used as the initial value to start
	     * the accumulation. The first call to the callbackfn function provides this value as an argument
	     * instead of an array value.
	     */
	    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U;
	    /**
	     * Calls the specified callback function for all the elements in an array, in descending order.
	     * The return value of the callback function is the accumulated result, and is provided as an
	     * argument in the next call to the callback function.
	     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
	     * the callbackfn function one time for each element in the array.
	     * @param initialValue If initialValue is specified, it is used as the initial value to start
	     * the accumulation. The first call to the callbackfn function provides this value as an
	     * argument instead of an array value.
	     */
	    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number;
	    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number;
	    /**
	     * Calls the specified callback function for all the elements in an array, in descending order.
	     * The return value of the callback function is the accumulated result, and is provided as an
	     * argument in the next call to the callback function.
	     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
	     * the callbackfn function one time for each element in the array.
	     * @param initialValue If initialValue is specified, it is used as the initial value to start
	     * the accumulation. The first call to the callbackfn function provides this value as an argument
	     * instead of an array value.
	     */
	    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U;
	    /**
	     * Reverses the elements in an Array.
	     */
	    reverse(): Float32Array;
	    /**
	     * Returns a section of an array.
	     * @param start The beginning of the specified portion of the array.
	     * @param end The end of the specified portion of the array.
	     */
	    slice(start?: number, end?: number): Float32Array;
	    /**
	     * Determines whether the specified callback function returns true for any element of an array.
	     * @param callbackfn A function that accepts up to three arguments. The some method calls the
	     * callbackfn function for each element in array1 until the callbackfn returns true, or until
	     * the end of the array.
	     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
	     * If thisArg is omitted, undefined is used as the this value.
	     */
	    some(callbackfn: (value: number, index: number, array: Float32Array) => boolean, thisArg?: any): boolean;
	    /**
	     * Gets a new Float32Array view of the ArrayBuffer store for this array, referencing the elements
	     * at begin, inclusive, up to end, exclusive.
	     * @param begin The index of the beginning of the array.
	     * @param end The index of the end of the array.
	     */
	    subarray(begin: number, end?: number): Float32Array;
	    /** @protected */
	    includes(searchElement: number, fromIndex?: number | undefined): boolean;
	}

}
declare module 'webdnn/descriptor_runner/descriptor_runner' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { GraphDescriptor } from 'webdnn/graph_descriptor/graph_descriptor';
	import PlaceholderContext from 'webdnn/placeholder';
	import SymbolicFloat32Array from 'webdnn/symbolic_typed_array/symbolic_float32array';
	import { BackendName } from 'webdnn/webdnn';
	export interface DescriptorRunnerOptions {
	    transformUrlDelegate?: (base: string) => string;
	}
	/**
	 * @protected
	 */
	export interface DescriptorRunnerConstructor<D extends GraphDescriptor, P> {
	    new (option: DescriptorRunnerOptions): DescriptorRunner<D, P>;
	    checkAvailability(): boolean;
	}
	/**
	 * `DescriptorRunner` provides interface to execute DNN model and access input and output buffers.
	 */
	export abstract class DescriptorRunner<D extends GraphDescriptor, P> {
	    constructor(option?: DescriptorRunnerOptions);
	    /**
	     * For Developer:
	     *
	     * `DescriptorRunner` executes computation based on `GraphDescriptor`.
	     *
	     * Typically, DescriptorRunner takes 3 steps to execute DNN model.
	     *
	     * 1. Initialize static configurations
	     *
	     *    Initialize things independent from runtime configuration.
	     *
	     *      - `init()`
	     *      - `load()`
	     *
	     * 2. Initialize dynamic configurations
	     *
	     *    Initialize things depend on runtime configuration such as batch size, input image size, etc.
	     *
	     *      - `setPlaceholderValue()`
	     *      - `getInputViews()`
	     *      - `getOutputViews()`
	     *
	     * 3. Execute the model
	     *
	     *      - `run()`
	     *
	     * You need to do step 1 and 2 only once. We recommend to call `WebDNN.prepareAll()` instead
	     * to call `GraphDescriptor#load()` directly. In that method, all procedures in step 1 and 2 are performed.
	     */
	    /**
	     * The backend name
	     */
	    readonly backendName: BackendName;
	    readonly transformUrlDelegate: (base: string) => string;
	    /**
	     * The descriptor
	     */
	    protected descriptor: D | null;
	    /**
	     * placeholder context which manages all placeholders and their values
	     */
	    protected placeholderContext: PlaceholderContext | null;
	    /**
	     * input arrays
	     */
	    inputs: SymbolicFloat32Array[];
	    /**
	     * outputs arrays
	     */
	    outputs: SymbolicFloat32Array[];
	    /**
	     * Return `true` if this backend is available in this environment.
	     * @returns {boolean}
	     */
	    static checkAvailability(): boolean;
	    /**
	     * Initialize descriptor runner asynchronously
	     * @returns {Promise<void>} Promise object which is resolved when the initialization finished.
	     * @protected
	     */
	    abstract init(): Promise<void>;
	    /**
	     * set graph descriptor and parameters
	     * @protected
	     */
	    abstract setDescriptorAndParameters(descriptor: D, parameters: P): Promise<void>;
	    /**
	     * Fetch graph descriptor from specified directory.
	     *
	     * @param directory directory where descriptor is contained.
	     * You can also provide URL of other domain like this.
	     *
	     * ```javascript
	     * await runner.load('://my.other.domain.com/my_model');
	     * ```
	     *
	     * However sometimes it can't because of Cross-Origin-Resource-Security policy.
	     *
	     * @protected
	     */
	    abstract fetchDescriptor(directory: string): Promise<D>;
	    /**
	     * Fetch parameter files from specified directory.
	     *
	     * @param directory directory where descriptor is contained.
	     * You can also provide URL of other domain like this.
	     *
	     * ```javascript
	     * await runner.load('://my.other.domain.com/my_model');
	     * ```
	     *
	     * However sometimes it can't because of Cross-Origin-Resource-Security policy.
	     *
	     * @param progressCallback callback which is called to notice the loading is progressing.
	     * @protected
	     */
	    abstract fetchParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<P>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    abstract restoreCachedDescriptor(directory: string): Promise<D | null>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    abstract restoreCachedParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<P | null>;
	    /**
	     * save cache
	     * @protected
	     */
	    abstract saveCache(directory: string, descriptor: D, parameters: P): Promise<void>;
	    /**
	     * Set actual value into placeholders. If no placeholder is exist in graph descriptor, it's no need to call this function.
	     *
	     * @param values dictionary object of placeholder name and value pair
	     * @protected
	     */
	    abstract setPlaceholderValue(values: {
	        [key: string]: number;
	    }): Promise<void>;
	    /**
	     * Get input [[webdnn.SymbolicFloat32Array|`SymbolicFloat32Array`]] object
	     *
	     * @protected
	     * @returns array of input [[webdnn.SymbolicFloat32Array|`SymbolicFloat32Array`]]
	     * @deprecated use [[webdnn.DescriptorRunner.inputs| `inputs`]] instead.
	     */
	    abstract getInputViews(): SymbolicFloat32Array[];
	    /**
	     * Get output [[webdnn.SymbolicFloat32Array|`SymbolicFloat32Array`]] object
	     *
	     * @protected
	     * @returns array of output [[webdnn.SymbolicFloat32Array|`SymbolicFloat32Array`]]
	     * @deprecated use [[webdnn.DescriptorRunner.outputs| `outputs`]] instead.
	     */
	    abstract getOutputViews(): SymbolicFloat32Array[];
	    /**
	     * Run descriptor. You must call [[webdnn.DescriptorRunner.getInputViews|`getInputViews`]] and
	     * [[webdnn.DescriptorRunner.getOutputViews|`getOutputViews`]] before calling this function.
	     */
	    abstract run(): Promise<void>;
	}

}
declare module 'webdnn/decoder/weight_decoder' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	/**
	 * @protected
	 */
	interface WeightDecoder {
	    decode(data: Uint8Array): Promise<Float32Array>;
	}
	export default WeightDecoder;

}
declare module 'webdnn/decoder/weight_decoder_eightbit' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import WeightDecoder from 'webdnn/decoder/weight_decoder';
	/**
	 * @protected
	 */
	export default class WeightDecoderEightbit implements WeightDecoder {
	    static decode_table: number[];
	    decode(data: Uint8Array): Promise<Float32Array>;
	}

}
declare module 'webdnn/decoder/weight_decoder_raw' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import WeightDecoder from 'webdnn/decoder/weight_decoder';
	/**
	 * @protected
	 */
	export default class WeightDecoderRaw implements WeightDecoder {
	    decode(data: Uint8Array): Promise<Float32Array>;
	}

}
declare module 'webdnn/decoder/get_weight_decoder' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import WeightDecoder from 'webdnn/decoder/weight_decoder';
	/**
	 * @protected
	 */
	export default function getWeightDecoder(name: string): WeightDecoder;

}
declare module 'webdnn/util/dispatch_scheduler' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	/**
	 * Schedule function which is called too much frequently.
	 *
	 * @private
	 */
	export default class DispatchScheduler {
	    private scheduledCallbackId;
	    private fn;
	    /**
	     * Register scheduled function. If already other function is scheduled, it is canceled and dispatcher will dispatch only
	     * function which is registered at last.
	     * @param fn scheduled function
	     */
	    request(fn: () => any): void;
	    /**
	     * Dispatch scheduled function just now. If no function is scheduled, dispatcher do nothing.
	     */
	    forceDispatch(): void;
	    /**
	     * Cancel scheduled function. If no function is scheduled, dispatcher do nothing.
	     */
	    cancel(): void;
	}

}
declare module 'webdnn/fetch' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	/**
	 * @protected
	 */
	export interface WebDNNRequestInit extends RequestInit {
	    ignoreCache: boolean;
	    progressCallback?: (loaded: number, total: number) => any;
	}
	/**
	 * Fetch function. WebDNN API use this function instead of original `fetch` function.
	 * FIXME
	 * @param input Requested url
	 * @param transformUrlDelegate url transform function
	 * @param init? Additional information about webdnnFetch
	 * @param init?.ignoreCache If true, cache is ignored by appending '?t=(timestamp)' to the end of request url.
	 * @returns Response
	 * @protected
	 */
	export default function webdnnFetch(input: RequestInfo, transformUrlDelegate: (base: string) => string, init?: WebDNNRequestInit): Promise<any>;
	/**
	 * Read `Response.body` stream as ArrayBuffer. This function provide progress information by callback.
	 * @param res Response object
	 * @param callback Callback function.
	 * @returns ArrayBuffer
	 * @protected
	 */
	export function readArrayBufferProgressively(res: Response, callback?: (loaded: number, total: number) => any): Promise<ArrayBuffer>;

}
declare module 'webdnn/graph_descriptor/graph_descriptor_fallback' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { GraphDescriptor } from 'webdnn/graph_descriptor/graph_descriptor';
	/**
	 * @protected
	 */
	export interface GraphDescriptorFallback extends GraphDescriptor {
	    kernel_source: string;
	    exec_infos: GraphDescriptorFallbackExecInfo[];
	}
	/**
	 * @protected
	 */
	export interface GraphDescriptorFallbackExecInfo {
	    entry_func_name: string;
	    inputs: string[];
	    outputs: string[];
	    weights: string[];
	    call_option: any;
	}

}
declare module 'webdnn/descriptor_runner/descriptor_runner_fallback' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { GraphDescriptorFallback } from 'webdnn/graph_descriptor/graph_descriptor_fallback';
	import SymbolicFloat32Array from 'webdnn/symbolic_typed_array/symbolic_float32array';
	import { BackendName } from 'webdnn/webdnn';
	import { DescriptorRunner, DescriptorRunnerOptions } from 'webdnn/descriptor_runner/descriptor_runner';
	/**
	 * @protected
	 */
	export default class DescriptorRunnerFallback extends DescriptorRunner<GraphDescriptorFallback, ArrayBuffer> {
	    readonly backendName: BackendName;
	    private kernelObj;
	    private variableMap;
	    private staticBuffer;
	    private dynamicBuffer;
	    private directory;
	    static checkAvailability(): boolean;
	    constructor(options?: DescriptorRunnerOptions);
	    init(): Promise<void>;
	    setDescriptorAndParameters(descriptor: GraphDescriptorFallback, parameters: ArrayBuffer): Promise<void>;
	    fetchDescriptor(directory: string): Promise<any>;
	    fetchParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<ArrayBuffer>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    restoreCachedDescriptor(directory: string): Promise<GraphDescriptorFallback | null>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    restoreCachedParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<ArrayBuffer | null>;
	    /**
	     * save cache
	     */
	    saveCache(directory: string, descriptor: GraphDescriptorFallback, parameters: ArrayBuffer): Promise<void>;
	    private setDescriptor;
	    private compile;
	    private initializeStaticBuffer;
	    private initializeDynamicBuffer;
	    setPlaceholderValue(values: {
	        [key: string]: number;
	    }): Promise<void>;
	    run(): Promise<void>;
	    getInputViews(): SymbolicFloat32Array[];
	    getOutputViews(): SymbolicFloat32Array[];
	}

}
declare module 'webdnn/graph_descriptor/graph_descriptor_webassembly' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { Placeholder } from 'webdnn/placeholder';
	import { GraphDescriptor } from 'webdnn/graph_descriptor/graph_descriptor';
	/**
	 * @protected
	 */
	export interface GraphDescriptorWebassembly extends GraphDescriptor {
	    unresolved_value_lists: {
	        offset: number;
	        placeholder: Placeholder;
	    }[][];
	}

}
declare module 'webdnn/descriptor_runner/descriptor_runner_webassembly' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { GraphDescriptorWebassembly } from 'webdnn/graph_descriptor/graph_descriptor_webassembly';
	import SymbolicFloat32Array from 'webdnn/symbolic_typed_array/symbolic_float32array';
	import { BackendName } from 'webdnn/webdnn';
	import { DescriptorRunner, DescriptorRunnerOptions } from 'webdnn/descriptor_runner/descriptor_runner';
	/**
	 * @protected
	 */
	export default class DescriptorRunnerWebassembly extends DescriptorRunner<GraphDescriptorWebassembly, ArrayBuffer> {
	    readonly backendName: BackendName;
	    private worker;
	    private worker_entry_js_path;
	    private worker_promise_reject_func;
	    private worker_initial_error;
	    private directory;
	    static checkAvailability(): boolean;
	    constructor(options?: DescriptorRunnerOptions);
	    init(): Promise<void>;
	    private absolutePath;
	    setDescriptorAndParameters(descriptor: GraphDescriptorWebassembly, parameters: ArrayBuffer): Promise<void>;
	    /**
	     * Fetch graph descriptor from specified directory.
	     *
	     * @param directory directory where descriptor is contained.
	     * You can also provide URL of other domain like this.
	     *
	     * ```javascript
	     * await runner.load('://my.other.domain.com/my_model');
	     * ```
	     *
	     * However sometimes it can't because of Cross-Origin-Resource-Security policy.
	     *
	     * @protected
	     */
	    fetchDescriptor(directory: string): Promise<GraphDescriptorWebassembly>;
	    /**
	     * Fetch parameter files from specified directory.
	     *
	     * @param directory directory where descriptor is contained.
	     * You can also provide URL of other domain like this.
	     *
	     * ```javascript
	     * await runner.load('://my.other.domain.com/my_model');
	     * ```
	     *
	     * However sometimes it can't because of Cross-Origin-Resource-Security policy.
	     *
	     * @param progressCallback callback which is called to notice the loading is progressing.
	     * @protected
	     */
	    fetchParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<ArrayBuffer>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    restoreCachedDescriptor(directory: string): Promise<GraphDescriptorWebassembly | null>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    restoreCachedParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<ArrayBuffer | null>;
	    /**
	     * save cache
	     */
	    saveCache(directory: string, descriptor: GraphDescriptorWebassembly, parameters: ArrayBuffer): Promise<void>;
	    setPlaceholderValue(values: {
	        [key: string]: number;
	    }): Promise<void>;
	    private setPlaceholderValueWorker;
	    private compile;
	    private loadWeights;
	    getInputViews(): SymbolicFloat32Array[];
	    getOutputViews(): SymbolicFloat32Array[];
	    run(): Promise<void>;
	}

}
declare module 'webdnn/graph_descriptor/graph_descriptor_webgl' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { Placeholder } from 'webdnn/placeholder';
	import { GraphDescriptor } from 'webdnn/graph_descriptor/graph_descriptor';
	import { Allocation, MemoryLayout, ResolvedAllocation } from 'webdnn/graph_descriptor/memory_layout';
	/**
	 * @protected
	 */
	export type ChannelMode = 'RGBA' | 'R';
	/**
	 * @protected
	 */
	export interface WebGLMemoryLayout extends MemoryLayout {
	    'static': {
	        size: -1;
	        allocations: {
	            [index: string]: ResolvedWebGLAllocation;
	        };
	    };
	    dynamic: {
	        size: -1;
	        allocations: {
	            [index: string]: WebGLAllocation;
	        };
	    };
	    mapping: {
	        [variableName: string]: string;
	    };
	}
	/**
	 * @protected
	 */
	export interface ResolvedWebGLAllocation extends ResolvedAllocation, WebGLAllocation {
	    name: string;
	    offset: -1;
	    size: number;
	    width: number;
	    height: number;
	    channel_mode: ChannelMode;
	}
	/**
	 * @protected
	 */
	export interface WebGLAllocation extends Allocation {
	    name: string;
	    offset: -1;
	    size: number | Placeholder;
	    width: number | Placeholder;
	    height: number | Placeholder;
	    channel_mode: ChannelMode;
	}
	/**
	 * @protected
	 */
	export interface GraphDescriptorWebGL extends GraphDescriptor {
	    shader_sources: {
	        [name: string]: string;
	    };
	    exec_infos: GraphDescriptorWebGLExecInfos[];
	    memory_layout: WebGLMemoryLayout;
	    constants_map: {
	        [variable_name: string]: {
	            size: number;
	            byte_offset: number;
	        };
	    };
	}
	/**
	 * @protected
	 */
	export interface GraphDescriptorWebGLExecInfos {
	    shader_name: string;
	    uniforms: {
	        [name: string]: {
	            type: 'int' | 'float' | 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' | 'sampler2D';
	            value: number;
	        };
	    };
	    inputs: [{
	        variable_name: string;
	        uniform_name: string;
	        value: number;
	    }];
	    output: string;
	    width: number;
	}

}
declare namespace WebGL2RenderingContext {
}


declare class WebGL2RenderingContext extends WebGLRenderingContext {
    RED: GLenum;
    RGBA32F: GLenum;
    R32F: GLenum;
    SYNC_GPU_COMMANDS_COMPLETE: GLenum;
    ALREADY_SIGNALED: GLenum;
    CONDITION_SATISFIED: GLenum;

    createVertexArray(): WebGLVertexArrayObject;

    bindVertexArray(vertexArray: WebGLVertexArrayObject): void;

    fenceSync(condition: GLenum, flags: GLbitfield): WebGLSync;

    clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: 0): GLenum;

    deleteSync(sync: WebGLSync): void;
}

declare class WebGLVertexArrayObject {

}

declare class WebGLSync {

}

declare interface WebGLVertexArrayObjectExtension {
    bindVertexArrayOES(vertexArray: WebGLVertexArrayObject): void;

    createVertexArrayOES(): WebGLVertexArrayObject;
}
declare module 'webdnn/webgl_handler' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	/// <reference path="webgl2.d.ts" />
	/**
	 * @protected
	 */
	export function isWebGL2(gl: WebGLRenderingContext | WebGL2RenderingContext): gl is WebGL2RenderingContext;
	/**
	 * @protected
	 */
	export default class WebGLHandler {
	    static IS_SAFARI: boolean;
	    readonly gl: WebGLRenderingContext | WebGL2RenderingContext;
	    static getInstance(): WebGLHandler;
	    /**
	     * WebGLHandler is singleton class and instantiate directly is forbidden (constructor is hidden).
	     *
	     * Since the number of GPU contexts may be limited, the handler is used as a singleton
	     * and only one context is shared among multiple runners.
	     */
	    private constructor();
	    createTexture(textureWidth: number, textureHeight: number, internalFormat: number, format: number): WebGLTexture;
	    createVertexShader(source: string): WebGLShader;
	    createFragmentShader(source: string): WebGLShader;
	    createShader(type: number, source: string): WebGLShader;
	    createProgram(vertexShader: WebGLShader, fragmentShader: WebGLShader): WebGLProgram;
	    createArrayBuffer(vertexArray: Float32Array): WebGLBuffer;
	    createFrameBuffer(): WebGLFramebuffer;
	    bindArrayBuffer(buffer: WebGLBuffer): void;
	    bindFrameBuffer(frameBuffer: WebGLFramebuffer, width: number, height: number): void;
	    useProgram(program: WebGLProgram): void;
	    deleteTexture(texture: WebGLTexture): void;
	    static initializeWebGL2Context(canvas?: HTMLCanvasElement): WebGLRenderingContext | null;
	    static initializeWebGL1Context(canvas?: HTMLCanvasElement): WebGLRenderingContext | null;
	    static initializeContext(): WebGLRenderingContext | null;
	    /**
	     * Check whether WebGL is supported or not
	     * @protected
	     */
	    static checkAvailability(): boolean;
	    waitForComplete(): Promise<void>;
	    readonly MAX_TEXTURE_SIZE: number;
	}

}
declare module 'webdnn/buffer/buffer' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	/**
	 * Abstract buffer interface. Read/write transactions are regarded as asynchronous operation.
	 *
	 * @protected
	 */
	export abstract class Buffer {
	    /**
	     * @property {number}
	     */
	    byteLength: number;
	    backend: string;
	    constructor(byteLength: number, backend: string);
	    /**
	     * Write contents onto specified position synchronously.
	     *
	     * @param {ArrayBufferView} src contents source buffer
	     * @param {number} offset position where contents are written on
	     */
	    abstract write(src: ArrayBufferView, offset?: number): Promise<void>;
	    /**
	     * Read contents from specified position synchronously.
	     *
	     * @param {Float32ArrayConstructor | Int32ArrayConstructor} dst buffer where contents are written on
	     * @param {number} offset position where contents are read from
	     * @param {length} length contents length
	     */
	    abstract read(dst: Float32ArrayConstructor | Int32ArrayConstructor, offset?: number, length?: number): Promise<void>;
	    /**
	     * for a range which will be written from CPU iteratively, make view to avoid copy (if backend allows)
	     * if backend does not allow such operation, return newly allocated memory and send their contents to GPU when syncWriteViews is called
	     *
	     * @param {number} offset position where buffer-view begin from
	     * @param {number} length buffer-view length
	     * @param {Int32ArrayConstructor|Float32ArrayConstructor} type data format such as Float32Array, Int32Array, and so on.
	     */
	    abstract getWriteView(offset?: number, length?: number, type?: Int32ArrayConstructor): Int32Array;
	    abstract getWriteView(offset?: number, length?: number, type?: Float32ArrayConstructor): Float32Array;
	    /**
	     * for a range which will be read from CPU iteratively, make view to avoid copy (if backend allows)
	     * if backend does not allow such operation, return newly allocated memory and fill their contents from GPU when syncReadViews is called
	     *
	     * @param {number} offset position where buffer-view begin from
	     * @param {number} length buffer-view length
	     * @param {Int32ArrayConstructor|Float32ArrayConstructor} type data format such as Float32Array, Int32Array, and so on.
	     */
	    abstract getReadView(offset?: number, length?: number, type?: Int32ArrayConstructor): Int32Array;
	    abstract getReadView(offset?: number, length?: number, type?: Float32ArrayConstructor): Float32Array;
	    /**
	     * Sync buffered data into memory.
	     *
	     * @see Buffer#getWriteView
	     */
	    abstract syncWriteViews(): Promise<void>;
	    /**
	     * Sync memory data into buffer view.
	     *
	     * @see Buffer#getReadView
	     */
	    abstract syncReadViews(): Promise<void>;
	}

}
declare module 'webdnn/buffer/buffer_webgl' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { ChannelMode } from 'webdnn/graph_descriptor/graph_descriptor_webgl';
	import { Buffer } from 'webdnn/buffer/buffer';
	/**
	 * @protected
	 */
	export default class BufferWebGL extends Buffer {
	    private handler;
	    readonly channelMode: ChannelMode;
	    readonly elementsPerPixel: number;
	    readonly pixelStride: number;
	    readonly array: Float32Array;
	    readonly textureWidth: number;
	    readonly textureHeight: number;
	    readonly textureFormat: number;
	    readonly textureInternalFormat: number;
	    private _texture;
	    readonly name: string;
	    private readTextureUnitIndices;
	    private isBoundToDrawFrameBuffer;
	    constructor(byteLength: number, textureWidth: number, textureHeight: number, name: string, array: Float32Array | null, channelMode: ChannelMode);
	    readonly texture: WebGLTexture | null;
	    readonly length: number;
	    /**
	     * Write contents onto specified position synchronously.
	     *
	     * @param {ArrayBufferView} src contents source buffer
	     * @param {number} offset position where contents are written on
	     */
	    write(src: ArrayBufferView, offset?: number): Promise<void>;
	    /**
	     * Read contents from specified position synchronously.
	     *
	     * @param {Float32ArrayConstructor | Int32ArrayConstructor} dst buffer where contents are written on
	     * @param {number} offset position where contents are read from
	     * @param {length} length contents length
	     */
	    read(dst: Float32ArrayConstructor | Int32ArrayConstructor, offset?: number, length?: number): Promise<void>;
	    /**
	     * for a range which will be written from CPU iteratively, make view to avoid copy (if backend allows)
	     * if backend does not allow such operation, return newly allocated memory and send their contents to GPU when syncWriteViews is called
	     *
	     * @param {number} offset position where buffer-view begin from
	     * @param {number} length buffer-view length
	     * @param {Int32ArrayConstructor|Float32ArrayConstructor} type data format such as Float32Array, Int32Array, and so on.
	     */
	    getWriteView(offset: number, length: number, type: Int32ArrayConstructor): Int32Array;
	    getWriteView(offset: number, length: number, type: Float32ArrayConstructor): Float32Array;
	    /**
	     * for a range which will be read from CPU iteratively, make view to avoid copy (if backend allows)
	     * if backend does not allow such operation, return newly allocated memory and fill their contents from GPU when syncReadViews is called
	     *
	     * @param {number} offset position where buffer-view begin from
	     * @param {number} length buffer-view length
	     * @param {Int32ArrayConstructor|Float32ArrayConstructor} type data format such as Float32Array, Int32Array, and so on.
	     */
	    getReadView(offset: number, length: number, type: Int32ArrayConstructor): Int32Array;
	    getReadView(offset: number, length: number, type: Float32ArrayConstructor): Float32Array;
	    /**
	     * Sync buffered data into memory.
	     *
	     * @see Buffer#getWriteView
	     */
	    syncWriteViews(): Promise<void>;
	    /**
	     * Sync memory data into buffer view.
	     *
	     * @see Buffer#getReadView
	     */
	    syncReadViews(): Promise<void>;
	    bindToReadTexture(unit: number): Promise<void>;
	    unbindFromReadTexture(): void;
	    bindToDrawTexture(): void;
	    unbindFromDrawTexture(): void;
	    private pack;
	    private unpack;
	    private allocateTexture;
	}

}
declare module 'webdnn/descriptor_runner/descriptor_runner_webgl' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { GraphDescriptorWebGL } from 'webdnn/graph_descriptor/graph_descriptor_webgl';
	import SymbolicFloat32Array from 'webdnn/symbolic_typed_array/symbolic_float32array';
	import { BackendName } from 'webdnn/webdnn';
	import { DescriptorRunner, DescriptorRunnerOptions } from 'webdnn/descriptor_runner/descriptor_runner';
	/**
	 * @protected
	 */
	export default class DescriptorRunnerWebGL extends DescriptorRunner<GraphDescriptorWebGL, ArrayBuffer> {
	    readonly backendName: BackendName;
	    private runtimeInfo;
	    private handler;
	    private vertexShader;
	    private programs;
	    private buffers;
	    static checkAvailability(): boolean;
	    constructor(options?: DescriptorRunnerOptions);
	    init(): Promise<void>;
	    fetchDescriptor(directory: string): Promise<any>;
	    fetchParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<ArrayBuffer>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    restoreCachedDescriptor(directory: string): Promise<GraphDescriptorWebGL | null>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    restoreCachedParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<ArrayBuffer | null>;
	    /**
	     * save cache
	     */
	    saveCache(directory: string, descriptor: GraphDescriptorWebGL, parameters: ArrayBuffer): Promise<void>;
	    setDescriptorAndParameters(descriptor: GraphDescriptorWebGL, parameters: ArrayBuffer): Promise<void>;
	    private initializeStaticBuffer;
	    private initializeDynamicBuffer;
	    private setDescriptor;
	    private compile;
	    setPlaceholderValue(values: {
	        [key: string]: number;
	    }): Promise<void>;
	    getInputViews(): SymbolicFloat32Array[];
	    getOutputViews(): SymbolicFloat32Array[];
	    private buildPipeline;
	    run(): Promise<void>;
	}

}
declare module 'webdnn/webmetal_handler' {
	/// <reference path="webmetal.d.ts" />
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import BufferWebMetal from 'webdnn/buffer/buffer_webmetal';
	/**
	 * @protected
	 */
	export default class WebMetalHandler {
	    private context;
	    private commandQueue;
	    private pipelineStates;
	    private commandBuffer;
	    static getInstance(): WebMetalHandler;
	    /**
	     * WebMetalHandler is singleton class and instantiate directly is forbidden (constructor is hidden).
	     *
	     * Since the number of GPU contexts may be limited, the handler is used as a singleton
	     * and only one context is shared among multiple runners.
	     */
	    private constructor();
	    createBuffer(arrayBuffer: ArrayBufferView): WebMetalBuffer;
	    loadKernel(librarySource: string, namespace?: string): void;
	    createCommandBuffer(): WebMetalCommandBuffer;
	    getPipelineStateByName(name: string): WebMetalComputePipelineState;
	    executeSinglePipelineState(name: string, threadgroupsPerGrid: WebMetalSize, threadsPerThreadgroup: WebMetalSize, buffers: (WebMetalBuffer | BufferWebMetal)[], getCompletedPromise?: boolean): Promise<void> | null;
	    sync(): Promise<void>;
	}
	/**
	 * Flag whether WebGPU on Safari is supported or not
	 * Its name was changed to WebMetal in 2019 (macOS 10.14.4 / iOS 12.2).
	 * This is used for backward compatibility.
	 * @protected
	 */
	export const IS_APPLE_WEBGPU_SUPPORTED: boolean;
	/**
	 * Flag whether WebMetal is supported or not
	 * @protected
	 */
	export const IS_WEBMETAL_SUPPORTED: boolean;

}
declare module 'webdnn/buffer/buffer_webmetal' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { Buffer } from 'webdnn/buffer/buffer';
	/**
	 * @protected
	 */
	export default class BufferWebMetal extends Buffer {
	    buffer: WebMetalBuffer;
	    bufferView: Uint8Array;
	    private handler;
	    constructor(byteLength: number);
	    write(src: ArrayBufferView, dst_offset?: number): Promise<void>;
	    read(dst: any, src_offset?: number, length?: number): Promise<void>;
	    getWriteView(offset: number, length: number, type: Int32ArrayConstructor): Int32Array;
	    getWriteView(offset: number, length: number, type: Float32ArrayConstructor): Float32Array;
	    getReadView(offset: number, length: number, type: Int32ArrayConstructor): Int32Array;
	    getReadView(offset: number, length: number, type: Float32ArrayConstructor): Float32Array;
	    syncWriteViews(): Promise<void>;
	    syncReadViews(): Promise<void>;
	}

}
declare module 'webdnn/graph_descriptor/graph_descriptor_webmetal' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { Placeholder } from 'webdnn/placeholder';
	import { GraphDescriptor } from 'webdnn/graph_descriptor/graph_descriptor';
	/**
	 * @protected
	 */
	export interface GraphDescriptorWebMetal extends GraphDescriptor {
	    kernel_source: string;
	    exec_infos: GraphDescriptorWebMetalExecInfos[];
	}
	/**
	 * @protected
	 */
	export interface GraphDescriptorWebMetalExecInfos {
	    entry_func_name: string;
	    threadgroups_per_grid: WebMetalSize;
	    threads_per_thread_group: WebMetalSize;
	    meta_buffer: number[];
	    unresolved_value_list: {
	        offset: number;
	        placeholder: Placeholder;
	    }[];
	}

}
declare module 'webdnn/descriptor_runner/descriptor_runner_webmetal' {
	/**
	 * @module webdnn
	 */
	/** Don't Remove This comment block */
	import { GraphDescriptorWebMetal } from 'webdnn/graph_descriptor/graph_descriptor_webmetal';
	import SymbolicFloat32Array from 'webdnn/symbolic_typed_array/symbolic_float32array';
	import { BackendName } from 'webdnn/webdnn';
	import { DescriptorRunner, DescriptorRunnerOptions } from 'webdnn/descriptor_runner/descriptor_runner';
	/**
	 * DescriptorRunner for WebMetal
	 * @protected
	 */
	export default class DescriptorRunnerWebMetal extends DescriptorRunner<GraphDescriptorWebMetal, ArrayBuffer> {
	    constructor(options?: DescriptorRunnerOptions);
	    /**
	     * backend name
	     */
	    readonly backendName: BackendName;
	    /**
	     * WebMetal Handler
	     */
	    private webmetalHandler;
	    /**
	     * Static buffer, whose size and layout can be determined in compile time.
	     */
	    private staticBuffer;
	    /**
	     * Buffers whose size and layout cannot be determined without runtime information like image size (if it's dynamic).
	     */
	    private dynamicBuffer;
	    /**
	     * Buffers which contains metadata shared in each GPU kernel thread (ex. hyper parameters).
	     */
	    private metaBuffers;
	    /**
	     * Execution information such as each kernel size, input and output buffers, etc.
	     */
	    private executionInfos;
	    /**
	     * Return `true` if this backend is available in this environment.
	     * @returns {boolean}
	     */
	    static checkAvailability(): boolean;
	    /**
	     * Initialize descriptor runner asynchronously
	     * @returns {Promise<void>} Promise object which is resolved when the initialization finished.
	     */
	    init(): Promise<void>;
	    /**
	     * Check whether current GPU is supported or not. If it's not supported, an error is thrown.
	     * @returns {Promise<void>}
	     */
	    private checkIncompatibleGPU;
	    /**
	     * Fetch graph descriptor from specified directory.
	     *
	     * @param directory directory where descriptor is contained.
	     * You can also provide URL of other domain like this.
	     *
	     * ```javascript
	     * await runner.load('://my.other.domain.com/my_model');
	     * ```
	     *
	     * However sometimes it can't because of Cross-Origin-Resource-Security policy.
	     *
	     * @protected
	     */
	    fetchDescriptor(directory: string): Promise<GraphDescriptorWebMetal>;
	    /**
	     * Fetch parameter files from specified directory.
	     *
	     * @param directory directory where descriptor is contained.
	     * You can also provide URL of other domain like this.
	     *
	     * ```javascript
	     * await runner.load('://my.other.domain.com/my_model');
	     * ```
	     *
	     * However sometimes it can't because of Cross-Origin-Resource-Security policy.
	     *
	     * @param progressCallback callback which is called to notice the loading is progressing.
	     * @protected
	     */
	    fetchParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<ArrayBuffer>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    restoreCachedDescriptor(directory: string): Promise<GraphDescriptorWebMetal | null>;
	    /**
	     * Load cached descriptor from WebStorage
	     * @protected
	     */
	    restoreCachedParameters(directory: string, progressCallback?: (loaded: number, total: number) => any): Promise<ArrayBuffer | null>;
	    /**
	     * save cache
	     */
	    saveCache(directory: string, descriptor: GraphDescriptorWebMetal, parameters: ArrayBuffer): Promise<void>;
	    setDescriptorAndParameters(descriptor: GraphDescriptorWebMetal, parameter: ArrayBuffer): Promise<void>;
	    /**
	     * Initialize static buffers, whose size and position can be determined in compile time.
	     *
	     * @param {ArrayBuffer} weightRawArray constant weight buffer
	     * @returns {Promise<void>}
	     */
	    private initializeStaticBuffer;
	    /**
	     * Initialize meta buffers, which contains metadata shared in each GPU kernel thread (ex. hyper parameters).
	     * @returns {Promise<void>}
	     */
	    private initializeMetaBuffers;
	    /**
	     * Initialize dynamic buffers, whose size and position cannot be determined without runtime-information such as input image size
	     * (if it's dynamic).
	     * When all placeholder is resolved, this method is automatically called.
	     *
	     * @returns {Promise<void>}
	     */
	    private initializeDynamicBuffer;
	    /**
	     * Set actual value into placeholder. If all placeholder is resolved,
	     * [[DescriptorRunnerWebMetal#initializeDynamicBuffer|`initializeDynamicBuffer()`]] is automatically called.
	     *
	     * @param values mapping object of placeholder name and value
	     * @returns {Promise<void>}
	     */
	    setPlaceholderValue(values: {
	        [key: string]: number;
	    }): Promise<void>;
	    /**
	     * Get input [[webdnn.SymbolicFloat32Array|`SymbolicFloat32Array`]] object
	     *
	     * @returns array of input [[webdnn.SymbolicFloat32Array|`SymbolicFloat32Array`]]
	     * @deprecated Use [[webdnn.DescriptorRunner.inputs|`inputs`]] instead
	     */
	    getInputViews(): SymbolicFloat32Array[];
	    /**
	     * Get output [[webdnn.SymbolicFloat32Array|`SymbolicFloat32Array`]] object
	     *
	     * @returns array of output [[webdnn.SymbolicFloat32Array|`SymbolicFloat32Array`]]
	     * @deprecated Use [[webdnn.DescriptorRunner.outputs|`outputs`]] instead
	     */
	    getOutputViews(): SymbolicFloat32Array[];
	    /**
	     * Run descriptor. You must call [[webdnn.DescriptorRunner.getInputViews|`getInputViews`]] and
	     * [[webdnn.DescriptorRunner.getOutputViews|`getOutputViews`]] before calling this function.
	     */
	    run(): Promise<void>;
	}

}
declare module 'webdnn/image/enums' {
	/**
	 * @module webdnn/image
	 */
	/** Don't Remove This comment block */
	/**
	 * The data order
	 */
	export enum Order {
	    /** `[Channel, Height, Width]` format */
	    CHW = 0,
	    /** `[Height, Width, Channel]` format */
	    HWC = 1
	}
	/**
	 * The color format
	 */
	export enum Color {
	    /** RGB format */
	    RGB = 0,
	    /** BGR format */
	    BGR = 1,
	    /** grey scale */
	    GREY = 2,
	    /** RGBA format */
	    RGBA = 3,
	    /** BGRA format */
	    BGRA = 4
	}

}
declare module 'webdnn/image/canvas' {
	/**
	 * @module webdnn/image
	 */
	/** Don't Remove This comment block */
	/**
	 * Get canvas rendering context and check whether it is nonnull value.
	 *
	 * @param {CanvasRenderingContext2D} canvas
	 * @protected
	 */
	export function getContext2D(canvas: HTMLCanvasElement): CanvasRenderingContext2D;

}
declare module 'webdnn/image/image_data' {
	/**
	 * @module webdnn/image
	 */
	/** Don't Remove This comment block */
	/**
	 * The rectangle of source position of image
	 */
	export interface SourceRect {
	    srcX?: number;
	    srcY?: number;
	    srcW?: number;
	    srcH?: number;
	}
	/**
	 * The rectangle of destination position of image
	 */
	export interface DestinationRect {
	    dstX?: number;
	    dstY?: number;
	    dstW?: number;
	    dstH?: number;
	}
	/**
	 * @protected
	 */
	export function getImageDataFromCanvas(canvas: HTMLCanvasElement, options?: SourceRect & DestinationRect): ImageData;
	/**
	 * @protected
	 */
	export function getImageDataFromDrawable(drawable: HTMLVideoElement | HTMLImageElement, options?: SourceRect & DestinationRect): ImageData;
	/**
	 * Return canvas `ImageData` object with specified scale.
	 *
	 * @param {HTMLCanvasElement | HTMLVideoElement | HTMLImageElement} image
	 * @param [options] Options
	 * @param {number} [options.srcX=0] left position of input clipping rect
	 * @param {number} [options.srcY=0] top position of input clipping rect
	 * @param {number} [options.srcW=canvas.width] width of input clipping rect
	 * @param {number} [options.srcH=canvas.height] height of input clipping rect
	 * @param {number} [options.dstW=options.srcW] width of output
	 * @param {number} [options.dstH=options.srcH] height of output
	 * @returns {ImageData}
	 * @protected
	 */
	export function getImageData(image: HTMLCanvasElement | HTMLVideoElement | HTMLImageElement, options?: SourceRect & DestinationRect): ImageData;
	/**
	 * @protected
	 */
	export function setImageDataToCanvas(imageData: ImageData, canvas: HTMLCanvasElement, options?: SourceRect & DestinationRect): void;

}
declare module 'webdnn/image/image_source' {
	/**
	 * @module webdnn/image
	 */
	/** Don't Remove This comment block */
	/**
	 * Load image of specified url
	 *
	 * @param {string} url the image url
	 * @returns {Promise<HTMLImageElement>} image element
	 */
	export function loadImageByUrl(url: string): Promise<HTMLImageElement>;
	/**
	 * Load image file selected in `<input type="file">` element.
	 *
	 * @param {HTMLInputElement} input the `<input type="file">` element
	 * @returns {Promise<HTMLImageElement>} image element
	 */
	export function loadImageFromFileInput(input: HTMLInputElement): Promise<HTMLImageElement>;
	/**
	 * Load image selected in file picker dialog
	 *
	 * Currently, web specification not supported the case if the dialog is canceled and no file is selected. In this case,
	 * the returned promise will never be resolved.
	 *
	 * @returns {Promise<HTMLImageElement>} image element
	 * @protected
	 */
	export function loadImageByDialog(): Promise<HTMLImageElement>;

}
declare module 'webdnn/image/image_array' {
	/**
	 * @module webdnn/image
	 */
	/** Don't Remove This comment block */
	import { Color, Order } from 'webdnn/image/enums';
	import { DestinationRect, SourceRect } from 'webdnn/image/image_data';
	/**
	 * Option structure of [[webdnn/image.getImageArray|`WebDNN.Image.getImageArray`]]
	 */
	export interface ImageArrayOption {
	    /** Type of packed array */
	    type?: {
	        new (length: number): (Float32Array | Int32Array);
	    };
	    /** The color format */
	    color?: Color;
	    /** The data order */
	    order?: Order;
	    /** Bias value, which is parsed based on [[webdnn/image.ImageArrayOption.order|`order`]] value */
	    bias?: number[] | number;
	    /** Scale value, which is parsed based on [[webdnn/image.ImageArrayOption.order|`order`]] value */
	    scale?: number[] | number;
	}
	/**
	 * Types which are drawable at `HTMLCanvasElement`
	 */
	export type Drawable = HTMLImageElement | HTMLVideoElement | HTMLCanvasElement | ImageData;
	/**
	 * All type of image source which `WebDNN.Image` can be handled. For `string`, only the url of image resource is valid.
	 */
	export type ImageSource = string | HTMLInputElement | Drawable;
	/**
	 * Get image array as `{Float32 or Int32}ArrayBufferView` from ImageData object.
	 *
	 * @returns {ArrayBufferView} buffer with specified type
	 * @protected
	 */
	export function getImageArrayFromImageData(imageData: ImageData, options?: SourceRect & DestinationRect & ImageArrayOption): Float32Array | Int32Array;
	/**
	 * Get image array from canvas element as `{Float32 or Int32}ArrayBufferView`.
	 *
	 * @returns {ImageData} buffer with specified type
	 * @protected
	 */
	export function getImageArrayFromCanvas(canvas: HTMLCanvasElement, options?: SourceRect & DestinationRect & ImageArrayOption): Float32Array | Int32Array;
	/**
	 * Get image array from image element as `{Float32 or Int32}ArrayBufferView`.
	 *
	 * @returns {ImageData} buffer with specified type
	 * @protected
	 */
	export function getImageArrayFromDrawable(drawable: Drawable, options?: SourceRect & DestinationRect & ImageArrayOption): Float32Array | Int32Array;
	/**
	 * Create typed array by packing image data from image source with specified options.
	 *
	 * First, this method loads specified image resource. The behavior of this method depends on the `image` argument.
	 *
	 * - If `image` is an instance of `string`, it will be regarded as image url, and this method fetches that url.
	 *
	 * - If `image` is an instance of `HTMLInputElement`, it will be regarded as file input,
	 *   and this method loads the selected image file.
	 *
	 * - Otherwise, `image` will be regarded as drawable object.
	 *
	 * Then, loaded images are packed into typed array based on `options` argument.
	 *
	 * - The image is cropped based on [[SourceRect|`{srcX, srcY, srcW, srcH}`]].
	 *   As default, entire image is used.
	 *
	 * - The image is resized and translated into [[DestinationRect|`{dstX, dstY, dstW, dstH}`]].
	 *   As default, no resize and translation is performed.
	 *
	 * - [[ImageArrayOption.type|`options.type`]] is the type of packed typed array. As default, Float32Array is used.
	 *
	 * - [[ImageArrayOption.type|`options.color`]] is the color format of packed typed array. As default, [[Color.RGB|`RGB`]] is used.
	 *
	 * - [[ImageArrayOption.type|`options.order`]] is the data order of packed typed array. As default, [[Order.HWC|`HWC`]] is used.
	 *
	 * - [[ImageArrayOption.bias|`options.bias`]] is the bias value.
	 *   If specified, this method **subtracts** this value from original pixel value.
	 *
	 * - [[ImageArrayOption.scale|`options.scale`]] is the scale value. If specified, original pixel values are **divided** by this value.
	 *   [[ImageArrayOption.scale|`options.scale`]] and [[ImageArrayOption.bias|`options.bias`]] is used for converting pixel value `x` and
	 *   packed value `y` as follows:
	 *
	 *   - `y = (x - bias) / scale`
	 *   - `x = y * scale + bias`
	 *   - Note that color order is always RGB, not BGR.
	 *
	 * ### Examples
	 *
	 * - Load image of specified url
	 *
	 *   ```ts
	 *   let image = await WebDNN.Image.load('./cat.png');
	 *   ```
	 *
	 * - Load image selected in file input and resize it into 224 x 224
	 *
	 *   ```ts
	 *   let input = document.querySelector('input[type=file]');
	 *   let image = await WebDNN.Image.load(input, { dstW: 224, dstH: 224 });
	 *   ```
	 *
	 * - Load image data from canvas, normalize it into range `[-1, 1)`. In this case, normalized value `y` can be
	 *   calculated from pixel value `x` as follows: `y = (x - 128) / 128`.
	 *
	 *   ```ts
	 *   let canvas = document.getElementsByTagName('canvas')[0];
	 *   let image = await WebDNN.Image.load(canvas, { bias: [128, 128, 128], scale: [128, 128, 128] });
	 *   ```
	 *
	 * @param image please see above descriptions
	 * @param options please see above descriptions.
	 * @returns Created typed array
	 */
	export function getImageArray(image: ImageSource, options?: SourceRect & DestinationRect & ImageArrayOption): Promise<Float32Array | Int32Array>;
	/**
	 * Set image array data into canvas.
	 *
	 * ### Examples
	 *
	 * - Show DNN model's result
	 *
	 *   ```ts
	 *   let runner = await WebDNN.load('./model');
	 *   let output = runner.outputs[0];
	 *
	 *   await runner.run();
	 *
	 *   WebDNN.Image.setImageArrayToCanvas(output.toActual(), 256, 256, document.getElementById('canvas'))
	 *   ```
	 *
	 * - Generally image generation model's result contains noise pixel at their edge because of convolution's padding.
	 *   In follow example, these noise are cut off.
	 *
	 *   ```ts
	 *   WebDNN.Image.setImageArrayToCanvas(output, 256, 256, canvas, {
	 *      srcX: 16, srcY: 16, srcH: 256-16*2, srcW: 256-16*2, // Discard both ends 16px
	 *      dstW: 256, dstH: 256  // Resize cropped image into original output size.
	 *   });
	 *   ```
	 *
	 * @param array array which contains image data
	 * @param imageW width of image
	 * @param imageH height of image. The length of `array` must be `imageW * imageH * (# of channels)`
	 * @param canvas destination canvas
	 * @param options please see above descriptions and descriptions in [[webdnn/image.getImageArray|getImageArray()]].
	 *                `srcW` and `srcH` is ignored (overwritten by `imageW` and `imageH`).
	 */
	export function setImageArrayToCanvas(array: Float32Array | Int32Array, imageW: number, imageH: number, canvas: HTMLCanvasElement, options?: SourceRect & DestinationRect & ImageArrayOption): void;

}
declare module 'webdnn/image' {
	/**
	 * @module webdnn/image
	 * @preferred
	 *
	 * Module `WebDNN.Image` provides basic image processing operations like follows.
	 *
	 * - Load image by various way (File picker dialog, url string, canvas, video, etc.)
	 * - Pack image data into TypedArray
	 * - Crop and resize.
	 * - Show result on canvas element
	 *
	 */
	/** Don't Remove This comment block */
	export * from 'webdnn/image/enums';
	export * from 'webdnn/image/image_array';
	export * from 'webdnn/image/image_source';

}
declare module 'webdnn/math/argsort' {
	/**
	 * @module webdnn/math
	 */
	/** Don't Remove This comment block */
	/**
	 * Return indices of the top-K largest elements.
	 * This implementation is not stable sort.
	 *
	 * @param {number[]|Float32Array} arr array
	 * @param {number} k number of indices
	 * @returns {number[]} indices of top-K largest samples
	 */
	export function argmax(arr: number[] | Float32Array, k?: number): number[];
	/**
	 * Return indices of the top-K smallest elements.
	 * This implementation is not stable sort.
	 *
	 * @param {number[]|Float32Array|Int32Array} arr array
	 * @param {number} k number of indices
	 * @returns {number[]} indices of top-K smallest samples
	 */
	export function argmin(arr: number[] | Float32Array | Int32Array, k?: number): number[];

}
declare module 'webdnn/math' {
	/**
	 * @module webdnn/math
	 * @preferred
	 *
	 * Module `WebDNN.Math` provides basic mathematics operations for pre/post-processing.
	 */
	/** Don't Remove This comment block */
	export * from 'webdnn/math/argsort';

}
declare module 'webdnn/webdnn' {
	/// <reference path="webmetal.d.ts" />
	/**
	 * @module webdnn
	 * @preferred
	 *
	 * Module `WebDNN` provides main features of WebDNN.
	 */
	/** Don't Remove This comment block */
	import { DescriptorRunner as DescriptorRunnerGeneric } from 'webdnn/descriptor_runner/descriptor_runner';
	import { GraphDescriptor } from 'webdnn/graph_descriptor/graph_descriptor';
	import * as Image from 'webdnn/image';
	import * as Math from 'webdnn/math';
	/**
	 * get configuration
	 * @private
	 */
	export function getConfiguration<T>(key: string, defaultValue?: T): T;
	/**
	 * set configuration
	 * @private
	 */
	export function setConfiguration(key: string, value: any): void;
	/**
	 * Backend names supported in WebDNN
	 */
	export type BackendName = 'webgpu' | 'webgl' | 'webassembly' | 'fallback';
	/**
	 * Descriptor runner
	 */
	export type DescriptorRunner = DescriptorRunnerGeneric<GraphDescriptor, any>;
	/**
	 * Result structure of [[getBackendAvailability|`WebDNN.getBackendAvailability`]]
	 */
	export interface BackendAvailability {
	    /**
	     * Whether each backend is available or not.
	     *
	     * ### Example
	     *
	     * ```ts
	     * WebDNN.getBackendAvailability().status
	     * >>> {
	     *   'webgpu': false,
	     *   'webassembly': true,
	     *   'webgl': true,
	     *   'fallback': true
	     * }
	     * ```
	     */
	    status: {
	        [name in BackendName]: boolean;
	    };
	    /**
	     * Default backend order WebDNN try to use
	     *
	     * ### Examples
	     *
	     * ```ts
	     * WebDNN.getBackendAvailability().defaultOrder
	     * >>> ['webassembly', 'webgl', 'fallback']
	     * ```
	     */
	    defaultOrder: BackendName[];
	}
	/**
	 * Check each computing backend is available or not in this browser.
	 * The result will be returned as [[BackendAvailability|`BackendAvailability`]] structure.
	 *
	 * @returns backend availability
	 */
	export function getBackendAvailability(): BackendAvailability;
	/**
	 * Option structure of [[load|`WebDNN.load`]]
	 */
	export interface InitOption {
	    /**
	     * The order of backend names to be initialized.
	     */
	    backendOrder?: BackendName | (BackendName[]);
	    /**
	     * Backend-specific options. Currently (v1.3), this option has no effect.
	     */
	    backendOptions?: {
	        [key: string]: any;
	    };
	    /**
	     * Callback function which is called to notice the progress status of loading binary data.
	     *
	     * Currently Streaming fetch feature is not perfectly supported in browsers. Therefore, this option will be
	     * ignored in some web browsers.
	     *
	     * ### Examples
	     *
	     * ```js
	     * let runner = await WebDNN.load('./model', {
	     *     progressCallback: (loaded, total) => console.log(`${ (loaded/total*100).toFixed(1) }% Loaded`);
	     * });
	     * ```
	     */
	    progressCallback?: (loaded: number, total: number) => any;
	    /**
	     * URL of directory that contains weight binary files.
	     *
	     * If both
	     * [[InitOption.weightDirectory|`InitOption.weightDirectory`]] and
	     * [[InitOption.transformUrlDelegate|`InitOption.transformUrlDelegate`]] are specified,
	     * At first, all urls of binary weights' are replaced by [[InitOption.weightDirectory|`InitOption.weightDirectory`]], and then
	     * [[InitOption.transformUrlDelegate|`InitOption.transformUrlDelegate`]] are applied.
	     *
	     * ### Examples
	     *
	     * ```js
	     * // Graph descriptor JSON file will be loaded from 'original.host.com/model', and
	     * // model binary data will be loaded from 'custom.host.com/model'.
	     * WebDNN.load('https://original.host.com/model', {
	     *     weightDirectory: 'https://custom.host.com/model'
	     * });
	     * ```
	     */
	    weightDirectory?: string;
	    /**
	     * Delegate function which will be called with original url, and must return converted url strings.
	     * This function is called before WebDNN fetch any data (descriptor json file, and binary data)
	     * You can modified url to fetch data from other domain, for example.
	     *
	     * If both
	     * [[InitOption.weightDirectory|`InitOption.weightDirectory`]] and
	     * [[InitOption.transformUrlDelegate|`InitOption.transformUrlDelegate`]] are specified,
	     * At first, all urls of binary weights' are replaced by [[InitOption.weightDirectory|`InitOption.weightDirectory`]], and then
	     * [[InitOption.transformUrlDelegate|`InitOption.transformUrlDelegate`]] are applied.
	     *
	     * ### Examples
	     *
	     * Fetch binary data from other domain
	     *
	     * ```js
	     * // Graph descriptor JSON file will be loaded from 'original.host.com/model', and
	     * // model binary data will be loaded from 'custom.host.com/model'.
	     * WebDNN.load('https://original.host.com/model', {
	     *     transformUrlDelegate: (url) => {
	     *         if ((/\.bin/).test(url)) {
	     *             url = url.replace('original.host.com', 'custom.host.com');
	     *         }
	     *         return url;
	     *     }
	     * });
	     * ```
	     */
	    transformUrlDelegate?: (url: string) => string;
	    /**
	     * WebDNN cache strategy. One of follows is available.
	     *
	     * - `latest` (default)
	     *
	     *  Fetch `descriptor.json` at first and check whether assets in server is same as cached assets. If it's same, use cached assets,
	     *  otherwise, fetch all assets and replace cached assets.
	     *
	     * - `networkFirst`
	     *
	     *  Fetch all asset files. If it succeeds, use fetched assets. If failed, use cached assets if exist, otherwise, an error is thrown.
	     *
	     * - `cacheFirst`
	     *
	     *  If cache is exist, use cache, otherwise, fetch assets. If it failed, an error is thrown.
	     *
	     * - `networkOnly`
	     *
	     *  Fetch all asset files. If failed, an error is thrown.
	     *
	     * - `cacheOnly`
	     *
	     *  If cache is exist, use cache, otherwise, an error is thrown.
	     *
	     */
	    cacheStrategy?: 'latest' | 'networkFirst' | 'cacheFirst' | 'networkOnly' | 'cacheOnly';
	    /**
	     * If true, WebDNN save fetched parameter data cache in available `WebStorage`. As default, it's `true`.
	     */
	    saveCache?: boolean;
	}
	/**
	 * Initialize descriptor runner. This function performs follow things.
	 *
	 * 1. Try to initialize computing backend. WebDNN will try to initialize each backend in order of
	 *    the result of [[getBackendAvailability|`getBackendAvailability`]].
	 *    If you want to modify this order, specify [[InitOption.backendOrder|`initOption.backendOrder`]] option.
	 *
	 * 2. Load model data based on initialized backend. Generally, DNN binary data is very large and it takes long time to load.
	 *    [[InitOption.progressCallback|`initOption.progressCallback`]] option provides the progress status of loading.
	 *
	 * ### Examples
	 *
	 * - Basic usage
	 *
	 *   ```js
	 *   let runner = await WebDNN.load('./model');
	 *   ```
	 *
	 * - With `initOption.progressCallback` option
	 *
	 *   ```js
	 *   let runner = await WebDNN.load('./model', {
	 *       progressCallback: (loaded, total) => console.log(`${ (loaded/total*100).toFixed(1) }% Loaded`);
	 *   });
	 *   ```
	 *
	 * @param directory URL of directory that contains graph descriptor files (e.g. graph_webgpu.json)
	 * @param initOption Initialize option
	 * @return DescriptorRunner instance, which is the interface to input/output data and run the model.
	 */
	export function load(directory: string, initOption?: InitOption): Promise<DescriptorRunner>;
	export { GraphDescriptor };
	export { Math, Image };

}
declare module 'webdnn' {
	export * from 'webdnn/webdnn';
}