// Generated by dts-bundle-generator v9.5.1

import { FederatedPointerEvent, Graphics, Renderer, Text as Text$1 } from 'pixi.js';

export declare class HitAreaFrames extends Graphics {
	initialized: boolean;
	texts: Text$1[];
	strokeWidth: number;
	normalColor: number;
	activeColor: number;
	constructor();
	init(): void;
	onPointerMove(e: FederatedPointerEvent): void;
	/** @override */
	protected _render(renderer: Renderer): void;
}
declare class csmString {
	/**
	 * 文字列を後方に追加する
	 *
	 * @param c 追加する文字列
	 * @return 更新された文字列
	 */
	append(c: string, length?: number): csmString;
	/**
	 * 文字サイズを拡張して文字を埋める
	 * @param length    拡張する文字数
	 * @param v         埋める文字
	 * @return 更新された文字列
	 */
	expansion(length: number, v: string): csmString;
	/**
	 * 文字列の長さをバイト数で取得する
	 */
	getBytes(): number;
	/**
	 * 文字列の長さを返す
	 */
	getLength(): number;
	/**
	 * 文字列比較 <
	 * @param s 比較する文字列
	 * @return true:    比較する文字列より小さい
	 * @return false:   比較する文字列より大きい
	 */
	isLess(s: csmString): boolean;
	/**
	 * 文字列比較 >
	 * @param s 比較する文字列
	 * @return true:    比較する文字列より大きい
	 * @return false:   比較する文字列より小さい
	 */
	isGreat(s: csmString): boolean;
	/**
	 * 文字列比較 ==
	 * @param s 比較する文字列
	 * @return true:    比較する文字列と等しい
	 * @return false:   比較する文字列と異なる
	 */
	isEqual(s: string): boolean;
	/**
	 * 文字列が空かどうか
	 * @return true: 空の文字列
	 * @return false: 値が設定されている
	 */
	isEmpty(): boolean;
	/**
	 * 引数付きコンストラクタ
	 */
	constructor(s: string);
	s: string;
}
declare class CubismId {
	/**
	 * 内部で使用するCubismIdクラス生成メソッド
	 *
	 * @param id ID文字列
	 * @returns CubismId
	 * @note 指定したID文字列からCubismIdを取得する際は
	 *       CubismIdManager().getId(id)を使用してください
	 */
	static createIdInternal(id: string | csmString): CubismId;
	/**
	 * ID名を取得する
	 */
	getString(): csmString;
	/**
	 * idを比較
	 * @param c 比較するid
	 * @return 同じならばtrue,異なっていればfalseを返す
	 */
	isEqual(c: string | csmString | CubismId): boolean;
	/**
	 * idを比較
	 * @param c 比較するid
	 * @return 同じならばtrue,異なっていればfalseを返す
	 */
	isNotEqual(c: string | csmString | CubismId): boolean;
	/**
	 * プライベートコンストラクタ
	 *
	 * @note ユーザーによる生成は許可しません
	 */
	private constructor();
	private _id;
}
export declare type CubismIdHandle = CubismId;
declare class csmPair<_KeyT, _ValT> {
	/**
	 * コンストラクタ
	 * @param key Keyとしてセットする値
	 * @param value Valueとしてセットする値
	 */
	constructor(key?: _KeyT, value?: _ValT);
	first: _KeyT;
	second: _ValT;
}
declare class csmMap<_KeyT, _ValT> {
	/**
	 * 引数付きコンストラクタ
	 * @param size 初期化時点で確保するサイズ
	 */
	constructor(size?: number);
	/**
	 * デストラクタ
	 */
	release(): void;
	/**
	 * キーを追加する
	 * @param key 新たに追加するキー
	 */
	appendKey(key: _KeyT): void;
	/**
	 * 添字演算子[key]のオーバーロード(get)
	 * @param key 添字から特定されるValue値
	 */
	getValue(key: _KeyT): _ValT;
	/**
	 * 添字演算子[key]のオーバーロード(set)
	 * @param key 添字から特定されるValue値
	 * @param value 代入するValue値
	 */
	setValue(key: _KeyT, value: _ValT): void;
	/**
	 * 引数で渡したKeyを持つ要素が存在するか
	 * @param key 存在を確認するkey
	 * @return true 引数で渡したkeyを持つ要素が存在する
	 * @return false 引数で渡したkeyを持つ要素が存在しない
	 */
	isExist(key: _KeyT): boolean;
	/**
	 * keyValueのポインタを全て解放する
	 */
	clear(): void;
	/**
	 * コンテナのサイズを取得する
	 *
	 * @return コンテナのサイズ
	 */
	getSize(): number;
	/**
	 * コンテナのキャパシティを確保する
	 * @param newSize 新たなキャパシティ。引数の値が現在のサイズ未満の場合は何もしない。
	 * @param fitToSize trueなら指定したサイズに合わせる。falseならサイズを2倍確保しておく。
	 */
	prepareCapacity(newSize: number, fitToSize: boolean): void;
	/**
	 * コンテナの先頭要素を返す
	 */
	begin(): iterator<_KeyT, _ValT>;
	/**
	 * コンテナの終端要素を返す
	 */
	end(): iterator<_KeyT, _ValT>;
	/**
	 * コンテナから要素を削除する
	 *
	 * @param ite 削除する要素
	 */
	erase(ite: iterator<_KeyT, _ValT>): iterator<_KeyT, _ValT>;
	/**
	 * コンテナの値を32ビット符号付き整数型でダンプする
	 */
	dumpAsInt(): void;
	static readonly DefaultSize = 10;
	_keyValues: csmPair<_KeyT, _ValT>[];
	_dummyValue: _ValT;
	_size: number;
}
declare class iterator<_KeyT, _ValT> {
	/**
	 * コンストラクタ
	 */
	constructor(v?: csmMap<_KeyT, _ValT>, idx?: number);
	/**
	 * =演算子のオーバーロード
	 */
	set(ite: iterator<_KeyT, _ValT>): iterator<_KeyT, _ValT>;
	/**
	 * 前置き++演算子のオーバーロード
	 */
	preIncrement(): iterator<_KeyT, _ValT>;
	/**
	 * 前置き--演算子のオーバーロード
	 */
	preDecrement(): iterator<_KeyT, _ValT>;
	/**
	 * 後置き++演算子のオーバーロード
	 */
	increment(): iterator<_KeyT, _ValT>;
	/**
	 * 後置き--演算子のオーバーロード
	 */
	decrement(): iterator<_KeyT, _ValT>;
	/**
	 * *演算子のオーバーロード
	 */
	ptr(): csmPair<_KeyT, _ValT>;
	/**
	 * !=演算
	 */
	notEqual(ite: iterator<_KeyT, _ValT>): boolean;
	_index: number;
	_map: csmMap<_KeyT, _ValT>;
}
declare abstract class ICubismModelSetting {
	/**
	 * Mocファイルの名前を取得する
	 * @return Mocファイルの名前
	 */
	abstract getModelFileName(): string;
	/**
	 * モデルが使用するテクスチャの数を取得する
	 * テクスチャの数
	 */
	abstract getTextureCount(): number;
	/**
	 * テクスチャが配置されたディレクトリの名前を取得する
	 * @return テクスチャが配置されたディレクトリの名前
	 */
	abstract getTextureDirectory(): string;
	/**
	 * モデルが使用するテクスチャの名前を取得する
	 * @param index 配列のインデックス値
	 * @return テクスチャの名前
	 */
	abstract getTextureFileName(index: number): string;
	/**
	 * モデルに設定された当たり判定の数を取得する
	 * @return モデルに設定された当たり判定の数
	 */
	abstract getHitAreasCount(): number;
	/**
	 * 当たり判定に設定されたIDを取得する
	 *
	 * @param index 配列のindex
	 * @return 当たり判定に設定されたID
	 */
	abstract getHitAreaId(index: number): CubismIdHandle;
	/**
	 * 当たり判定に設定された名前を取得する
	 * @param index 配列のインデックス値
	 * @return 当たり判定に設定された名前
	 */
	abstract getHitAreaName(index: number): string;
	/**
	 * 物理演算設定ファイルの名前を取得する
	 * @return 物理演算設定ファイルの名前
	 */
	abstract getPhysicsFileName(): string;
	/**
	 * パーツ切り替え設定ファイルの名前を取得する
	 * @return パーツ切り替え設定ファイルの名前
	 */
	abstract getPoseFileName(): string;
	/**
	 * 表情設定ファイルの数を取得する
	 * @return 表情設定ファイルの数
	 */
	abstract getExpressionCount(): number;
	/**
	 * 表情設定ファイルを識別する名前（別名）を取得する
	 * @param index 配列のインデックス値
	 * @return 表情の名前
	 */
	abstract getExpressionName(index: number): string;
	/**
	 * 表情設定ファイルの名前を取得する
	 * @param index 配列のインデックス値
	 * @return 表情設定ファイルの名前
	 */
	abstract getExpressionFileName(index: number): string;
	/**
	 * モーショングループの数を取得する
	 * @return モーショングループの数
	 */
	abstract getMotionGroupCount(): number;
	/**
	 * モーショングループの名前を取得する
	 * @param index 配列のインデックス値
	 * @return モーショングループの名前
	 */
	abstract getMotionGroupName(index: number): string;
	/**
	 * モーショングループに含まれるモーションの数を取得する
	 * @param groupName モーショングループの名前
	 * @return モーショングループの数
	 */
	abstract getMotionCount(groupName: string): number;
	/**
	 * グループ名とインデックス値からモーションファイル名を取得する
	 * @param groupName モーショングループの名前
	 * @param index     配列のインデックス値
	 * @return モーションファイルの名前
	 */
	abstract getMotionFileName(groupName: string, index: number): string;
	/**
	 * モーションに対応するサウンドファイルの名前を取得する
	 * @param groupName モーショングループの名前
	 * @param index 配列のインデックス値
	 * @return サウンドファイルの名前
	 */
	abstract getMotionSoundFileName(groupName: string, index: number): string;
	/**
	 * モーション開始時のフェードイン処理時間を取得する
	 * @param groupName モーショングループの名前
	 * @param index 配列のインデックス値
	 * @return フェードイン処理時間[秒]
	 */
	abstract getMotionFadeInTimeValue(groupName: string, index: number): number;
	/**
	 * モーション終了時のフェードアウト処理時間を取得する
	 * @param groupName モーショングループの名前
	 * @param index 配列のインデックス値
	 * @return フェードアウト処理時間[秒]
	 */
	abstract getMotionFadeOutTimeValue(groupName: string, index: number): number;
	/**
	 * ユーザーデータのファイル名を取得する
	 * @return ユーザーデータのファイル名
	 */
	abstract getUserDataFile(): string;
	/**
	 * レイアウト情報を取得する
	 * @param outLayoutMap csmMapクラスのインスタンス
	 * @return true レイアウト情報が存在する
	 * @return false レイアウト情報が存在しない
	 */
	abstract getLayoutMap(outLayoutMap: csmMap<string, number>): boolean;
	/**
	 * 目パチに関連付けられたパラメータの数を取得する
	 * @return 目パチに関連付けられたパラメータの数
	 */
	abstract getEyeBlinkParameterCount(): number;
	/**
	 * 目パチに関連付けられたパラメータのIDを取得する
	 * @param index 配列のインデックス値
	 * @return パラメータID
	 */
	abstract getEyeBlinkParameterId(index: number): CubismIdHandle;
	/**
	 * リップシンクに関連付けられたパラメータの数を取得する
	 * @return リップシンクに関連付けられたパラメータの数
	 */
	abstract getLipSyncParameterCount(): number;
	/**
	 * リップシンクに関連付けられたパラメータの数を取得する
	 * @param index 配列のインデックス値
	 * @return パラメータID
	 */
	abstract getLipSyncParameterId(index: number): CubismIdHandle;
}
declare class csmVector<T> {
	/**
	 * 引数付きコンストラクタ
	 * @param iniitalCapacity 初期化後のキャパシティ。データサイズは_capacity * sizeof(T)
	 * @param zeroClear trueなら初期化時に確保した領域を0で埋める
	 */
	constructor(initialCapacity?: number);
	/**
	 * インデックスで指定した要素を返す
	 */
	at(index: number): T;
	/**
	 * 要素をセット
	 * @param index 要素をセットするインデックス
	 * @param value セットする要素
	 */
	set(index: number, value: T): void;
	/**
	 * コンテナを取得する
	 */
	get(offset?: number): T[];
	/**
	 * pushBack処理、コンテナに新たな要素を追加する
	 * @param value PushBack処理で追加する値
	 */
	pushBack(value: T): void;
	/**
	 * コンテナの全要素を解放する
	 */
	clear(): void;
	/**
	 * コンテナの要素数を返す
	 * @return コンテナの要素数
	 */
	getSize(): number;
	/**
	 * コンテナの全要素に対して代入処理を行う
	 * @param newSize 代入処理後のサイズ
	 * @param value 要素に代入する値
	 */
	assign(newSize: number, value: T): void;
	/**
	 * サイズ変更
	 */
	resize(newSize: number, value?: T): void;
	/**
	 * サイズ変更
	 */
	updateSize(newSize: number, value?: any, callPlacementNew?: boolean): void;
	/**
	 * コンテナにコンテナ要素を挿入する
	 * @param position 挿入する位置
	 * @param begin 挿入するコンテナの開始位置
	 * @param end 挿入するコンテナの終端位置
	 */
	insert(position: iterator$1<T>, begin: iterator$1<T>, end: iterator$1<T>): void;
	/**
	 * コンテナからインデックスで指定した要素を削除する
	 * @param index インデックス値
	 * @return true 削除実行
	 * @return false 削除範囲外
	 */
	remove(index: number): boolean;
	/**
	 * コンテナから要素を削除して他の要素をシフトする
	 * @param ite 削除する要素
	 */
	erase(ite: iterator$1<T>): iterator$1<T>;
	/**
	 * コンテナのキャパシティを確保する
	 * @param newSize 新たなキャパシティ。引数の値が現在のサイズ未満の場合は何もしない.
	 */
	prepareCapacity(newSize: number): void;
	/**
	 * コンテナの先頭要素を返す
	 */
	begin(): iterator$1<T>;
	/**
	 * コンテナの終端要素を返す
	 */
	end(): iterator$1<T>;
	getOffset(offset: number): csmVector<T>;
	_ptr: T[];
	_size: number;
	_capacity: number;
	static readonly DefaultSize = 10;
}
declare class iterator$1<T> {
	/**
	 * コンストラクタ
	 */
	constructor(v?: csmVector<T>, index?: number);
	/**
	 * 代入
	 */
	set(ite: iterator$1<T>): iterator$1<T>;
	/**
	 * 前置き++演算
	 */
	preIncrement(): iterator$1<T>;
	/**
	 * 前置き--演算
	 */
	preDecrement(): iterator$1<T>;
	/**
	 * 後置き++演算子
	 */
	increment(): iterator$1<T>;
	/**
	 * 後置き--演算子
	 */
	decrement(): iterator$1<T>;
	/**
	 * ptr
	 */
	ptr(): T;
	/**
	 * =演算子のオーバーロード
	 */
	substitution(ite: iterator$1<T>): iterator$1<T>;
	/**
	 * !=演算子のオーバーロード
	 */
	notEqual(ite: iterator$1<T>): boolean;
	_index: number;
	_vector: csmVector<T>;
}
declare abstract class Value {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * 要素を文字列型で返す(csmString型)
	 */
	abstract getString(defaultValue?: string, indent?: string): string;
	/**
	 * 要素を文字列型で返す(string)
	 */
	getRawString(defaultValue?: string, indent?: string): string;
	/**
	 * 要素を数値型で返す(number)
	 */
	toInt(defaultValue?: number): number;
	/**
	 * 要素を数値型で返す(number)
	 */
	toFloat(defaultValue?: number): number;
	/**
	 * 要素を真偽値で返す(boolean)
	 */
	toBoolean(defaultValue?: boolean): boolean;
	/**
	 * サイズを返す
	 */
	getSize(): number;
	/**
	 * 要素を配列で返す(Value[])
	 */
	getArray(defaultValue?: Value[]): Value[];
	/**
	 * 要素をコンテナで返す(array)
	 */
	getVector(defaultValue?: csmVector<Value>): csmVector<Value>;
	/**
	 * 要素をマップで返す(csmMap<csmString, Value>)
	 */
	getMap(defaultValue?: csmMap<string, Value>): csmMap<string, Value>;
	/**
	 * 添字演算子[index]
	 */
	getValueByIndex(index: number): Value;
	/**
	 * 添字演算子[string | csmString]
	 */
	getValueByString(s: string | csmString): Value;
	/**
	 * マップのキー一覧をコンテナで返す
	 *
	 * @return マップのキーの一覧
	 */
	getKeys(): csmVector<string>;
	/**
	 * Valueの種類がエラー値ならtrue
	 */
	isError(): boolean;
	/**
	 * Valueの種類がnullならtrue
	 */
	isNull(): boolean;
	/**
	 * Valueの種類が真偽値ならtrue
	 */
	isBool(): boolean;
	/**
	 * Valueの種類が数値型ならtrue
	 */
	isFloat(): boolean;
	/**
	 * Valueの種類が文字列ならtrue
	 */
	isString(): boolean;
	/**
	 * Valueの種類が配列ならtrue
	 */
	isArray(): boolean;
	/**
	 * Valueの種類がマップ型ならtrue
	 */
	isMap(): boolean;
	/**
	 * 引数の値と等しければtrue
	 */
	equals(value: csmString): boolean;
	equals(value: string): boolean;
	equals(value: number): boolean;
	equals(value: boolean): boolean;
	/**
	 * Valueの値が静的ならtrue、静的なら解放しない
	 */
	isStatic(): boolean;
	/**
	 * Valueにエラー値をセットする
	 */
	setErrorNotForClientCall(errorStr: string): Value;
	/**
	 * 初期化用メソッド
	 */
	static staticInitializeNotForClientCall(): void;
	/**
	 * リリース用メソッド
	 */
	static staticReleaseNotForClientCall(): void;
	protected _stringBuffer: string;
	private static dummyKeys;
	static errorValue: Value;
	static nullValue: Value;
	[key: string]: any;
}
declare class CubismJson {
	/**
	 * コンストラクタ
	 */
	constructor(buffer?: ArrayBuffer, length?: number);
	/**
	 * バイトデータから直接ロードしてパースする
	 *
	 * @param buffer バッファ
	 * @param size バッファサイズ
	 * @return CubismJsonクラスのインスタンス。失敗したらNULL
	 */
	static create(buffer: ArrayBuffer, size: number): CubismJson;
	/**
	 * パースしたJSONオブジェクトの解放処理
	 *
	 * @param instance CubismJsonクラスのインスタンス
	 */
	static delete(instance: CubismJson): void;
	/**
	 * パースしたJSONのルート要素を返す
	 */
	getRoot(): Value;
	/**
	 *  UnicodeのバイナリをStringに変換
	 *
	 * @param buffer 変換するバイナリデータ
	 * @return 変換後の文字列
	 */
	static arrayBufferToString(buffer: ArrayBuffer): string;
	/**
	 * エンコード、パディング
	 */
	private static pad;
	/**
	 * JSONのパースを実行する
	 * @param buffer    パース対象のデータバイト
	 * @param size      データバイトのサイズ
	 * return true : 成功
	 * return false: 失敗
	 */
	parseBytes(buffer: ArrayBuffer, size: number, parseCallback?: parseJsonObject): boolean;
	/**
	 * パース時のエラー値を返す
	 */
	getParseError(): string;
	/**
	 * ルート要素の次の要素がファイルの終端だったらtrueを返す
	 */
	checkEndOfFile(): boolean;
	/**
	 * JSONエレメントからValue(float,String,Value*,Array,null,true,false)をパースする
	 * エレメントの書式に応じて内部でParseString(), ParseObject(), ParseArray()を呼ぶ
	 *
	 * @param   buffer      JSONエレメントのバッファ
	 * @param   length      パースする長さ
	 * @param   begin       パースを開始する位置
	 * @param   outEndPos   パース終了時の位置
	 * @return      パースから取得したValueオブジェクト
	 */
	protected parseValue(buffer: string, length: number, begin: number, outEndPos: number[]): Value;
	/**
	 * 次の「"」までの文字列をパースする。
	 *
	 * @param   string  ->  パース対象の文字列
	 * @param   length  ->  パースする長さ
	 * @param   begin   ->  パースを開始する位置
	 * @param  outEndPos   ->  パース終了時の位置
	 * @return      パースした文F字列要素
	 */
	protected parseString(string: string, length: number, begin: number, outEndPos: number[]): string;
	/**
	 * JSONのオブジェクトエレメントをパースしてValueオブジェクトを返す
	 *
	 * @param buffer    JSONエレメントのバッファ
	 * @param length    パースする長さ
	 * @param begin     パースを開始する位置
	 * @param outEndPos パース終了時の位置
	 * @return パースから取得したValueオブジェクト
	 */
	protected parseObject(buffer: string, length: number, begin: number, outEndPos: number[]): Value;
	/**
	 * 次の「"」までの文字列をパースする。
	 * @param buffer    JSONエレメントのバッファ
	 * @param length    パースする長さ
	 * @param begin     パースを開始する位置
	 * @param outEndPos パース終了時の位置
	 * @return パースから取得したValueオブジェクト
	 */
	protected parseArray(buffer: string, length: number, begin: number, outEndPos: number[]): Value;
	_parseCallback: parseJsonObject;
	_error: string;
	_lineCount: number;
	_root: Value;
}
export interface parseJsonObject {
	(obj: Value, map: JsonMap): JsonMap;
}
declare class JsonFloat extends Value {
	/**
	 * コンストラクタ
	 */
	constructor(v: number);
	/**
	 * Valueの種類が数値型ならtrue
	 */
	isFloat(): boolean;
	/**
	 * 要素を文字列で返す(csmString型)
	 */
	getString(defaultValue: string, indent: string): string;
	/**
	 * 要素を数値型で返す(number)
	 */
	toInt(defaultValue?: number): number;
	/**
	 * 要素を数値型で返す(number)
	 */
	toFloat(defaultValue?: number): number;
	/**
	 * 引数の値と等しければtrue
	 */
	equals(value: csmString): boolean;
	equals(value: string): boolean;
	equals(value: number): boolean;
	equals(value: boolean): boolean;
	private _value;
}
declare class JsonBoolean extends Value {
	/**
	 * Valueの種類が真偽値ならtrue
	 */
	isBool(): boolean;
	/**
	 * 要素を真偽値で返す(boolean)
	 */
	toBoolean(defaultValue?: boolean): boolean;
	/**
	 * 要素を文字列で返す(csmString型)
	 */
	getString(defaultValue: string, indent: string): string;
	/**
	 * 引数の値と等しければtrue
	 */
	equals(value: csmString): boolean;
	equals(value: string): boolean;
	equals(value: number): boolean;
	equals(value: boolean): boolean;
	/**
	 * Valueの値が静的ならtrue, 静的なら解放しない
	 */
	isStatic(): boolean;
	/**
	 * 引数付きコンストラクタ
	 */
	constructor(v: boolean);
	static trueValue: JsonBoolean;
	static falseValue: JsonBoolean;
	private _boolValue;
}
declare class JsonString extends Value {
	/**
	 * 引数付きコンストラクタ
	 */
	constructor(s: string);
	constructor(s: csmString);
	/**
	 * Valueの種類が文字列ならtrue
	 */
	isString(): boolean;
	/**
	 * 要素を文字列で返す(csmString型)
	 */
	getString(defaultValue: string, indent: string): string;
	/**
	 * 引数の値と等しければtrue
	 */
	equals(value: csmString): boolean;
	equals(value: string): boolean;
	equals(value: number): boolean;
	equals(value: boolean): boolean;
}
declare class JsonError extends JsonString {
	/**
	 * Valueの値が静的ならtrue、静的なら解放しない
	 */
	isStatic(): boolean;
	/**
	 * エラー情報をセットする
	 */
	setErrorNotForClientCall(s: string): Value;
	/**
	 * 引数付きコンストラクタ
	 */
	constructor(s: csmString | string, isStatic: boolean);
	/**
	 * Valueの種類がエラー値ならtrue
	 */
	isError(): boolean;
	protected _isStatic: boolean;
}
declare class JsonNullvalue extends Value {
	/**
	 * Valueの種類がNULL値ならtrue
	 */
	isNull(): boolean;
	/**
	 * 要素を文字列で返す(csmString型)
	 */
	getString(defaultValue: string, indent: string): string;
	/**
	 * Valueの値が静的ならtrue, 静的なら解放しない
	 */
	isStatic(): boolean;
	/**
	 * Valueにエラー値をセットする
	 */
	setErrorNotForClientCall(s: string): Value;
	/**
	 * コンストラクタ
	 */
	constructor();
}
declare class JsonArray extends Value {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * Valueの種類が配列ならtrue
	 */
	isArray(): boolean;
	/**
	 * 添字演算子[index]
	 */
	getValueByIndex(index: number): Value;
	/**
	 * 添字演算子[string | csmString]
	 */
	getValueByString(s: string | csmString): Value;
	/**
	 * 要素を文字列で返す(csmString型)
	 */
	getString(defaultValue: string, indent: string): string;
	/**
	 * 配列要素を追加する
	 * @param v 追加する要素
	 */
	add(v: Value): void;
	/**
	 * 要素をコンテナで返す(csmVector<Value>)
	 */
	getVector(defaultValue?: csmVector<Value>): csmVector<Value>;
	/**
	 * 要素の数を返す
	 */
	getSize(): number;
	private _array;
}
declare class JsonMap extends Value {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * Valueの値がMap型ならtrue
	 */
	isMap(): boolean;
	/**
	 * 添字演算子[string | csmString]
	 */
	getValueByString(s: string | csmString): Value;
	/**
	 * 添字演算子[index]
	 */
	getValueByIndex(index: number): Value;
	/**
	 * 要素を文字列で返す(csmString型)
	 */
	getString(defaultValue: string, indent: string): string;
	/**
	 * 要素をMap型で返す
	 */
	getMap(defaultValue?: csmMap<string, Value>): csmMap<string, Value>;
	/**
	 * Mapに要素を追加する
	 */
	put(key: string, v: Value): void;
	/**
	 * Mapからキーのリストを取得する
	 */
	getKeys(): csmVector<string>;
	/**
	 * Mapの要素数を取得する
	 */
	getSize(): number;
	private _map;
	private _keys;
}
declare class CubismMatrix44 {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * 受け取った２つの行列の乗算を行う。
	 *
	 * @param a 行列a
	 * @param b 行列b
	 * @return 乗算結果の行列
	 */
	static multiply(a: Float32Array, b: Float32Array, dst: Float32Array): void;
	/**
	 * 単位行列に初期化する
	 */
	loadIdentity(): void;
	/**
	 * 行列を設定
	 *
	 * @param tr 16個の浮動小数点数で表される4x4の行列
	 */
	setMatrix(tr: Float32Array): void;
	/**
	 * 行列を浮動小数点数の配列で取得
	 *
	 * @return 16個の浮動小数点数で表される4x4の行列
	 */
	getArray(): Float32Array;
	/**
	 * X軸の拡大率を取得
	 * @return X軸の拡大率
	 */
	getScaleX(): number;
	/**
	 * Y軸の拡大率を取得する
	 *
	 * @return Y軸の拡大率
	 */
	getScaleY(): number;
	/**
	 * X軸の移動量を取得
	 * @return X軸の移動量
	 */
	getTranslateX(): number;
	/**
	 * Y軸の移動量を取得
	 * @return Y軸の移動量
	 */
	getTranslateY(): number;
	/**
	 * X軸の値を現在の行列で計算
	 *
	 * @param src X軸の値
	 * @return 現在の行列で計算されたX軸の値
	 */
	transformX(src: number): number;
	/**
	 * Y軸の値を現在の行列で計算
	 *
	 * @param src Y軸の値
	 * @return 現在の行列で計算されたY軸の値
	 */
	transformY(src: number): number;
	/**
	 * X軸の値を現在の行列で逆計算
	 */
	invertTransformX(src: number): number;
	/**
	 * Y軸の値を現在の行列で逆計算
	 */
	invertTransformY(src: number): number;
	/**
	 * 現在の行列の位置を起点にして移動
	 *
	 * 現在の行列の位置を起点にして相対的に移動する。
	 *
	 * @param x X軸の移動量
	 * @param y Y軸の移動量
	 */
	translateRelative(x: number, y: number): void;
	/**
	 * 現在の行列の位置を移動
	 *
	 * 現在の行列の位置を指定した位置へ移動する
	 *
	 * @param x X軸の移動量
	 * @param y y軸の移動量
	 */
	translate(x: number, y: number): void;
	/**
	 * 現在の行列のX軸の位置を指定した位置へ移動する
	 *
	 * @param x X軸の移動量
	 */
	translateX(x: number): void;
	/**
	 * 現在の行列のY軸の位置を指定した位置へ移動する
	 *
	 * @param y Y軸の移動量
	 */
	translateY(y: number): void;
	/**
	 * 現在の行列の拡大率を相対的に設定する
	 *
	 * @param x X軸の拡大率
	 * @param y Y軸の拡大率
	 */
	scaleRelative(x: number, y: number): void;
	/**
	 * 現在の行列の拡大率を指定した倍率に設定する
	 *
	 * @param x X軸の拡大率
	 * @param y Y軸の拡大率
	 */
	scale(x: number, y: number): void;
	/**
	 * 引数で与えられた行列にこの行列を乗算する。
	 * (引数で与えられた行列) * (この行列)
	 *
	 * @note 関数名と実際の計算内容に乖離があるため、今後計算順が修正される可能性があります。
	 * @param m 行列
	 */
	multiplyByMatrix(m: CubismMatrix44): void;
	/**
	 * オブジェクトのコピーを生成する
	 */
	clone(): CubismMatrix44;
	protected _tr: Float32Array;
}
declare class csmRect {
	/**
	 * コンストラクタ
	 * @param x 左端X座標
	 * @param y 上端Y座標
	 * @param w 幅
	 * @param h 高さ
	 */
	constructor(x?: number, y?: number, w?: number, h?: number);
	/**
	 * 矩形中央のX座標を取得する
	 */
	getCenterX(): number;
	/**
	 * 矩形中央のY座標を取得する
	 */
	getCenterY(): number;
	/**
	 * 右側のX座標を取得する
	 */
	getRight(): number;
	/**
	 * 下端のY座標を取得する
	 */
	getBottom(): number;
	/**
	 * 矩形に値をセットする
	 * @param r 矩形のインスタンス
	 */
	setRect(r: csmRect): void;
	/**
	 * 矩形中央を軸にして縦横を拡縮する
	 * @param w 幅方向に拡縮する量
	 * @param h 高さ方向に拡縮する量
	 */
	expand(w: number, h: number): void;
	x: number;
	y: number;
	width: number;
	height: number;
}
export type ClippingContextConstructor<T_ClippingContext extends CubismClippingContext> = new (manager: CubismClippingManager<T_ClippingContext>, drawableMasks: Int32Array, drawableMaskCounts: number) => T_ClippingContext;
export interface ICubismClippingManager {
	getClippingMaskBufferSize(): number;
}
declare abstract class CubismClippingManager<T_ClippingContext extends CubismClippingContext> implements ICubismClippingManager {
	/**
	 * コンストラクタ
	 */
	constructor(clippingContextFactory: ClippingContextConstructor<T_ClippingContext>);
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * マネージャの初期化処理
	 * クリッピングマスクを使う描画オブジェクトの登録を行う
	 * @param model モデルのインスタンス
	 * @param renderTextureCount バッファの生成数
	 */
	initialize(model: CubismModel, renderTextureCount: number): void;
	/**
	 * 既にマスクを作っているかを確認
	 * 作っている様であれば該当するクリッピングマスクのインスタンスを返す
	 * 作っていなければNULLを返す
	 * @param drawableMasks 描画オブジェクトをマスクする描画オブジェクトのリスト
	 * @param drawableMaskCounts 描画オブジェクトをマスクする描画オブジェクトの数
	 * @return 該当するクリッピングマスクが存在すればインスタンスを返し、なければNULLを返す
	 */
	findSameClip(drawableMasks: Int32Array, drawableMaskCounts: number): T_ClippingContext;
	/**
	 * 高精細マスク処理用の行列を計算する
	 * @param model モデルのインスタンス
	 * @param isRightHanded 処理が右手系であるか
	 */
	setupMatrixForHighPrecision(model: CubismModel, isRightHanded: boolean): void;
	/**
	 * マスク作成・描画用の行列を作成する。
	 * @param isRightHanded 座標を右手系として扱うかを指定
	 * @param layoutBoundsOnTex01 マスクを収める領域
	 * @param scaleX 描画オブジェクトの伸縮率
	 * @param scaleY 描画オブジェクトの伸縮率
	 */
	createMatrixForMask(isRightHanded: boolean, layoutBoundsOnTex01: csmRect, scaleX: number, scaleY: number): void;
	/**
	 * クリッピングコンテキストを配置するレイアウト
	 * 指定された数のレンダーテクスチャを極力いっぱいに使ってマスクをレイアウトする
	 * マスクグループの数が4以下ならRGBA各チャンネルに一つずつマスクを配置し、5以上6以下ならRGBAを2,2,1,1と配置する。
	 *
	 * @param usingClipCount 配置するクリッピングコンテキストの数
	 */
	setupLayoutBounds(usingClipCount: number): void;
	/**
	 * マスクされる描画オブジェクト群全体を囲む矩形（モデル座標系）を計算する
	 * @param model モデルのインスタンス
	 * @param clippingContext クリッピングマスクのコンテキスト
	 */
	calcClippedDrawTotalBounds(model: CubismModel, clippingContext: T_ClippingContext): void;
	/**
	 * 画面描画に使用するクリッピングマスクのリストを取得する
	 * @return 画面描画に使用するクリッピングマスクのリスト
	 */
	getClippingContextListForDraw(): csmVector<T_ClippingContext>;
	/**
	 * クリッピングマスクバッファのサイズを取得する
	 * @return クリッピングマスクバッファのサイズ
	 */
	getClippingMaskBufferSize(): number;
	/**
	 * このバッファのレンダーテクスチャの枚数を取得する
	 * @return このバッファのレンダーテクスチャの枚数
	 */
	getRenderTextureCount(): number;
	/**
	 * カラーチャンネル（RGBA）のフラグを取得する
	 * @param channelNo カラーチャンネル（RGBA）の番号（0:R, 1:G, 2:B, 3:A）
	 */
	getChannelFlagAsColor(channelNo: number): CubismTextureColor;
	/**
	 * クリッピングマスクバッファのサイズを設定する
	 * @param size クリッピングマスクバッファのサイズ
	 */
	setClippingMaskBufferSize(size: number): void;
	protected _clearedFrameBufferFlags: csmVector<boolean>;
	protected _channelColors: csmVector<CubismTextureColor>;
	protected _clippingContextListForMask: csmVector<T_ClippingContext>;
	protected _clippingContextListForDraw: csmVector<T_ClippingContext>;
	protected _clippingMaskBufferSize: number;
	protected _renderTextureCount: number;
	protected _tmpMatrix: CubismMatrix44;
	protected _tmpMatrixForMask: CubismMatrix44;
	protected _tmpMatrixForDraw: CubismMatrix44;
	protected _tmpBoundsOnModel: csmRect;
	protected _clippingContexttConstructor: ClippingContextConstructor<T_ClippingContext>;
}
declare abstract class CubismRenderer {
	/**
	 * レンダラのインスタンスを生成して取得する
	 *
	 * @return レンダラのインスタンス
	 */
	static create(): CubismRenderer;
	/**
	 * レンダラのインスタンスを解放する
	 */
	static delete(renderer: CubismRenderer): void;
	/**
	 * レンダラの初期化処理を実行する
	 * 引数に渡したモデルからレンダラの初期化処理に必要な情報を取り出すことができる
	 * @param model モデルのインスタンス
	 */
	initialize(model: CubismModel): void;
	/**
	 * モデルを描画する
	 */
	drawModel(): void;
	/**
	 * Model-View-Projection 行列をセットする
	 * 配列は複製されるので、元の配列は外で破棄して良い
	 * @param matrix44 Model-View-Projection 行列
	 */
	setMvpMatrix(matrix44: CubismMatrix44): void;
	/**
	 * Model-View-Projection 行列を取得する
	 * @return Model-View-Projection 行列
	 */
	getMvpMatrix(): CubismMatrix44;
	/**
	 * モデルの色をセットする
	 * 各色0.0~1.0の間で指定する（1.0が標準の状態）
	 * @param red 赤チャンネルの値
	 * @param green 緑チャンネルの値
	 * @param blue 青チャンネルの値
	 * @param alpha αチャンネルの値
	 */
	setModelColor(red: number, green: number, blue: number, alpha: number): void;
	/**
	 * モデルの色を取得する
	 * 各色0.0~1.0の間で指定する(1.0が標準の状態)
	 *
	 * @return RGBAのカラー情報
	 */
	getModelColor(): CubismTextureColor;
	/**
	 * 透明度を考慮したモデルの色を計算する。
	 *
	 * @param opacity 透明度
	 *
	 * @return RGBAのカラー情報
	 */
	getModelColorWithOpacity(opacity: number): CubismTextureColor;
	/**
	 * 乗算済みαの有効・無効をセットする
	 * 有効にするならtrue、無効にするならfalseをセットする
	 */
	setIsPremultipliedAlpha(enable: boolean): void;
	/**
	 * 乗算済みαの有効・無効を取得する
	 * @return true 乗算済みのα有効
	 * @return false 乗算済みのα無効
	 */
	isPremultipliedAlpha(): boolean;
	/**
	 * カリング（片面描画）の有効・無効をセットする。
	 * 有効にするならtrue、無効にするならfalseをセットする
	 */
	setIsCulling(culling: boolean): void;
	/**
	 * カリング（片面描画）の有効・無効を取得する。
	 * @return true カリング有効
	 * @return false カリング無効
	 */
	isCulling(): boolean;
	/**
	 * テクスチャの異方性フィルタリングのパラメータをセットする
	 * パラメータ値の影響度はレンダラの実装に依存する
	 * @param n パラメータの値
	 */
	setAnisotropy(n: number): void;
	/**
	 * テクスチャの異方性フィルタリングのパラメータをセットする
	 * @return 異方性フィルタリングのパラメータ
	 */
	getAnisotropy(): number;
	/**
	 * レンダリングするモデルを取得する
	 * @return レンダリングするモデル
	 */
	getModel(): CubismModel;
	/**
	 * マスク描画の方式を変更する。
	 * falseの場合、マスクを1枚のテクスチャに分割してレンダリングする（デフォルト）
	 * 高速だが、マスク個数の上限が36に限定され、質も荒くなる
	 * trueの場合、パーツ描画の前にその都度必要なマスクを描き直す
	 * レンダリング品質は高いが描画処理負荷は増す
	 * @param high 高精細マスクに切り替えるか？
	 */
	useHighPrecisionMask(high: boolean): void;
	/**
	 * マスクの描画方式を取得する
	 * @return true 高精細方式
	 * @return false デフォルト
	 */
	isUsingHighPrecisionMask(): boolean;
	/**
	 * コンストラクタ
	 */
	protected constructor();
	/**
	 * モデル描画の実装
	 */
	abstract doDrawModel(): void;
	/**
	 * モデル描画直前のレンダラのステートを保持する
	 */
	protected abstract saveProfile(): void;
	/**
	 * モデル描画直前のレンダラのステートを復帰する
	 */
	protected abstract restoreProfile(): void;
	/**
	 * レンダラが保持する静的なリソースを開放する
	 */
	static staticRelease: any;
	protected _mvpMatrix4x4: CubismMatrix44;
	protected _modelColor: CubismTextureColor;
	protected _isCulling: boolean;
	protected _isPremultipliedAlpha: boolean;
	protected _anisotropy: any;
	protected _model: CubismModel;
	protected _useHighPrecisionMask: boolean;
}
declare enum CubismBlendMode {
	CubismBlendMode_Normal = 0,// 通常
	CubismBlendMode_Additive = 1,// 加算
	CubismBlendMode_Multiplicative = 2
}
declare class CubismTextureColor {
	/**
	 * コンストラクタ
	 */
	constructor(r?: number, g?: number, b?: number, a?: number);
	r: number;
	g: number;
	b: number;
	a: number;
}
declare abstract class CubismClippingContext {
	/**
	 * 引数付きコンストラクタ
	 */
	constructor(clippingDrawableIndices: Int32Array, clipCount: number);
	/**
	 * このマスクを管理するマネージャのインスタンスを取得する
	 * @return クリッピングマネージャのインスタンス
	 */
	abstract getClippingManager(): ICubismClippingManager;
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * このマスクにクリップされる描画オブジェクトを追加する
	 *
	 * @param drawableIndex クリッピング対象に追加する描画オブジェクトのインデックス
	 */
	addClippedDrawable(drawableIndex: number): void;
	_isUsing: boolean;
	readonly _clippingIdList: Int32Array;
	_clippingIdCount: number;
	_layoutChannelIndex: number;
	_layoutBounds: csmRect;
	_allClippedDrawRect: csmRect;
	_matrixForMask: CubismMatrix44;
	_matrixForDraw: CubismMatrix44;
	_clippedDrawableIndexList: number[];
	_bufferIndex: number;
}
declare class ParameterRepeatData {
	/**
	 * Constructor
	 *
	 * @param isOverridden whether to be overriden
	 * @param isParameterRepeated override flag for settings
	 */
	constructor(isOverridden?: boolean, isParameterRepeated?: boolean);
	/**
	 * Whether to be overridden
	 */
	isOverridden: boolean;
	/**
	 * Override flag for settings
	 */
	isParameterRepeated: boolean;
}
declare class DrawableColorData {
	constructor(isOverridden?: boolean, color?: CubismTextureColor);
	isOverridden: boolean;
	color: CubismTextureColor;
	get isOverwritten(): boolean;
}
declare class PartColorData {
	constructor(isOverridden?: boolean, color?: CubismTextureColor);
	isOverridden: boolean;
	color: CubismTextureColor;
	get isOverwritten(): boolean;
}
declare class DrawableCullingData {
	/**
	 * コンストラクタ
	 *
	 * @param isOverridden
	 * @param isCulling
	 */
	constructor(isOverridden?: boolean, isCulling?: boolean);
	isOverridden: boolean;
	isCulling: boolean;
	get isOverwritten(): boolean;
}
declare class CubismModel {
	/**
	 * モデルのパラメータの更新
	 */
	update(): void;
	/**
	 * PixelsPerUnitを取得する
	 * @returns PixelsPerUnit
	 */
	getPixelsPerUnit(): number;
	/**
	 * キャンバスの幅を取得する
	 */
	getCanvasWidth(): number;
	/**
	 * キャンバスの高さを取得する
	 */
	getCanvasHeight(): number;
	/**
	 * パラメータを保存する
	 */
	saveParameters(): void;
	/**
	 * 乗算色を取得する
	 * @param index Drawablesのインデックス
	 * @returns 指定したdrawableの乗算色(RGBA)
	 */
	getMultiplyColor(index: number): CubismTextureColor;
	/**
	 * スクリーン色を取得する
	 * @param index Drawablesのインデックス
	 * @returns 指定したdrawableのスクリーン色(RGBA)
	 */
	getScreenColor(index: number): CubismTextureColor;
	/**
	 * 乗算色をセットする
	 * @param index Drawablesのインデックス
	 * @param color 設定する乗算色(CubismTextureColor)
	 */
	setMultiplyColorByTextureColor(index: number, color: CubismTextureColor): void;
	/**
	 * 乗算色をセットする
	 * @param index Drawablesのインデックス
	 * @param r 設定する乗算色のR値
	 * @param g 設定する乗算色のG値
	 * @param b 設定する乗算色のB値
	 * @param a 設定する乗算色のA値
	 */
	setMultiplyColorByRGBA(index: number, r: number, g: number, b: number, a?: number): void;
	/**
	 * スクリーン色をセットする
	 * @param index Drawablesのインデックス
	 * @param color 設定するスクリーン色(CubismTextureColor)
	 */
	setScreenColorByTextureColor(index: number, color: CubismTextureColor): void;
	/**
	 * スクリーン色をセットする
	 * @param index Drawablesのインデックス
	 * @param r 設定するスクリーン色のR値
	 * @param g 設定するスクリーン色のG値
	 * @param b 設定するスクリーン色のB値
	 * @param a 設定するスクリーン色のA値
	 */
	setScreenColorByRGBA(index: number, r: number, g: number, b: number, a?: number): void;
	/**
	 * partの乗算色を取得する
	 * @param partIndex partのインデックス
	 * @returns 指定したpartの乗算色
	 */
	getPartMultiplyColor(partIndex: number): CubismTextureColor;
	/**
	 * partのスクリーン色を取得する
	 * @param partIndex partのインデックス
	 * @returns 指定したpartのスクリーン色
	 */
	getPartScreenColor(partIndex: number): CubismTextureColor;
	/**
	 * partのOverrideColor setter関数
	 * @param partIndex partのインデックス
	 * @param r 設定する色のR値
	 * @param g 設定する色のG値
	 * @param b 設定する色のB値
	 * @param a 設定する色のA値
	 * @param partColors 設定するpartのカラーデータ配列
	 * @param drawableColors partに関連するDrawableのカラーデータ配列
	 */
	setPartColor(partIndex: number, r: number, g: number, b: number, a: number, partColors: csmVector<PartColorData>, drawableColors: csmVector<DrawableColorData>): void;
	/**
	 * 乗算色をセットする
	 * @param partIndex partのインデックス
	 * @param color 設定する乗算色(CubismTextureColor)
	 */
	setPartMultiplyColorByTextureColor(partIndex: number, color: CubismTextureColor): void;
	/**
	 * 乗算色をセットする
	 * @param partIndex partのインデックス
	 * @param r 設定する乗算色のR値
	 * @param g 設定する乗算色のG値
	 * @param b 設定する乗算色のB値
	 * @param a 設定する乗算色のA値
	 */
	setPartMultiplyColorByRGBA(partIndex: number, r: number, g: number, b: number, a: number): void;
	/**
	 * スクリーン色をセットする
	 * @param partIndex partのインデックス
	 * @param color 設定するスクリーン色(CubismTextureColor)
	 */
	setPartScreenColorByTextureColor(partIndex: number, color: CubismTextureColor): void;
	/**
	 * スクリーン色をセットする
	 * @param partIndex partのインデックス
	 * @param r 設定するスクリーン色のR値
	 * @param g 設定するスクリーン色のG値
	 * @param b 設定するスクリーン色のB値
	 * @param a 設定するスクリーン色のA値
	 */
	setPartScreenColorByRGBA(partIndex: number, r: number, g: number, b: number, a: number): void;
	/**
	 * Checks whether parameter repetition is performed for the entire model.
	 *
	 * @return true if parameter repetition is performed for the entire model; otherwise returns false.
	 */
	getOverrideFlagForModelParameterRepeat(): boolean;
	/**
	 * Sets whether parameter repetition is performed for the entire model.
	 * Use true to perform parameter repetition for the entire model, or false to not perform it.
	 */
	setOverrideFlagForModelParameterRepeat(isRepeat: boolean): void;
	/**
	 * Returns the flag indicating whether to override the parameter repeat.
	 *
	 * @param parameterIndex Parameter index
	 *
	 * @return true if the parameter repeat is overridden, false otherwise.
	 */
	getOverrideFlagForParameterRepeat(parameterIndex: number): boolean;
	/**
	 * Sets the flag indicating whether to override the parameter repeat.
	 *
	 * @param parameterIndex Parameter index
	 * @param value true if it is to be overridden; otherwise, false.
	 */
	setOverrideFlagForParameterRepeat(parameterIndex: number, value: boolean): void;
	/**
	 * Returns the repeat flag.
	 *
	 * @param parameterIndex Parameter index
	 *
	 * @return true if repeating, false otherwise.
	 */
	getRepeatFlagForParameterRepeat(parameterIndex: number): boolean;
	/**
	 * Sets the repeat flag.
	 *
	 * @param parameterIndex Parameter index
	 * @param value true to enable repeating, false otherwise.
	 */
	setRepeatFlagForParameterRepeat(parameterIndex: number, value: boolean): void;
	/**
	 * SDKから指定したモデルの乗算色を上書きするか
	 *
	 * @deprecated 名称変更のため非推奨 getOverrideFlagForModelMultiplyColors() に置き換え
	 *
	 * @returns true -> SDKからの情報を優先する
	 *          false -> モデルに設定されている色情報を使用
	 */
	getOverwriteFlagForModelMultiplyColors(): boolean;
	/**
	 * SDKから指定したモデルの乗算色を上書きするか
	 * @returns true -> SDKからの情報を優先する
	 *          false -> モデルに設定されている色情報を使用
	 */
	getOverrideFlagForModelMultiplyColors(): boolean;
	/**
	 * SDKから指定したモデルのスクリーン色を上書きするか
	 *
	 * @deprecated 名称変更のため非推奨 getOverrideFlagForModelScreenColors() に置き換え
	 *
	 * @returns true -> SDKからの情報を優先する
	 *          false -> モデルに設定されている色情報を使用
	 */
	getOverwriteFlagForModelScreenColors(): boolean;
	/**
	 * SDKから指定したモデルのスクリーン色を上書きするか
	 * @returns true -> SDKからの情報を優先する
	 *          false -> モデルに設定されている色情報を使用
	 */
	getOverrideFlagForModelScreenColors(): boolean;
	/**
	 * SDKから指定したモデルの乗算色を上書きするかセットする
	 *
	 * @deprecated 名称変更のため非推奨 setOverrideFlagForModelMultiplyColors(value: boolean) に置き換え
	 *
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverwriteFlagForModelMultiplyColors(value: boolean): void;
	/**
	 * SDKから指定したモデルの乗算色を上書きするかセットする
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverrideFlagForModelMultiplyColors(value: boolean): void;
	/**
	 * SDKから指定したモデルのスクリーン色を上書きするかセットする
	 *
	 * @deprecated 名称変更のため非推奨 setOverrideFlagForModelScreenColors(value: boolean) に置き換え
	 *
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverwriteFlagForModelScreenColors(value: boolean): void;
	/**
	 * SDKから指定したモデルのスクリーン色を上書きするかセットする
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverrideFlagForModelScreenColors(value: boolean): void;
	/**
	 * SDKから指定したDrawableIndexの乗算色を上書きするか
	 *
	 * @deprecated 名称変更のため非推奨 getOverrideFlagForDrawableMultiplyColors(drawableindex: number) に置き換え
	 *
	 * @returns true -> SDKからの情報を優先する
	 *          false -> モデルに設定されている色情報を使用
	 */
	getOverwriteFlagForDrawableMultiplyColors(drawableindex: number): boolean;
	/**
	 * SDKから指定したDrawableIndexの乗算色を上書きするか
	 * @returns true -> SDKからの情報を優先する
	 *          false -> モデルに設定されている色情報を使用
	 */
	getOverrideFlagForDrawableMultiplyColors(drawableindex: number): boolean;
	/**
	 * SDKから指定したDrawableIndexのスクリーン色を上書きするか
	 *
	 * @deprecated 名称変更のため非推奨 getOverrideFlagForDrawableScreenColors(drawableindex: number) に置き換え
	 *
	 * @returns true -> SDKからの情報を優先する
	 *          false -> モデルに設定されている色情報を使用
	 */
	getOverwriteFlagForDrawableScreenColors(drawableindex: number): boolean;
	/**
	 * SDKから指定したDrawableIndexのスクリーン色を上書きするか
	 * @returns true -> SDKからの情報を優先する
	 *          false -> モデルに設定されている色情報を使用
	 */
	getOverrideFlagForDrawableScreenColors(drawableindex: number): boolean;
	/**
	 * SDKから指定したDrawableIndexの乗算色を上書きするかセットする
	 *
	 * @deprecated 名称変更のため非推奨 setOverrideFlagForDrawableMultiplyColors(drawableindex: number, value: boolean) に置き換え
	 *
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverwriteFlagForDrawableMultiplyColors(drawableindex: number, value: boolean): void;
	/**
	 * SDKから指定したDrawableIndexの乗算色を上書きするかセットする
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverrideFlagForDrawableMultiplyColors(drawableindex: number, value: boolean): void;
	/**
	 * SDKから指定したDrawableIndexのスクリーン色を上書きするかセットする
	 *
	 * @deprecated 名称変更のため非推奨 setOverrideFlagForDrawableScreenColors(drawableindex: number, value: boolean) に置き換え
	 *
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverwriteFlagForDrawableScreenColors(drawableindex: number, value: boolean): void;
	/**
	 * SDKから指定したDrawableIndexのスクリーン色を上書きするかセットする
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverrideFlagForDrawableScreenColors(drawableindex: number, value: boolean): void;
	/**
	 * SDKからpartの乗算色を上書きするか
	 *
	 * @deprecated 名称変更のため非推奨 getOverrideColorForPartMultiplyColors(partIndex: number) に置き換え
	 *
	 * @param partIndex partのインデックス
	 * @returns true    ->  SDKからの情報を優先する
	 *          false   ->  モデルに設定されている色情報を使用
	 */
	getOverwriteColorForPartMultiplyColors(partIndex: number): boolean;
	/**
	 * SDKからpartの乗算色を上書きするか
	 * @param partIndex partのインデックス
	 * @returns true    ->  SDKからの情報を優先する
	 *          false   ->  モデルに設定されている色情報を使用
	 */
	getOverrideColorForPartMultiplyColors(partIndex: number): boolean;
	/**
	 * SDKからpartのスクリーン色を上書きするか
	 *
	 * @deprecated 名称変更のため非推奨 getOverrideColorForPartScreenColors(partIndex: number) に置き換え
	 *
	 * @param partIndex partのインデックス
	 * @returns true    ->  SDKからの情報を優先する
	 *          false   ->  モデルに設定されている色情報を使用
	 */
	getOverwriteColorForPartScreenColors(partIndex: number): boolean;
	/**
	 * SDKからpartのスクリーン色を上書きするか
	 * @param partIndex partのインデックス
	 * @returns true    ->  SDKからの情報を優先する
	 *          false   ->  モデルに設定されている色情報を使用
	 */
	getOverrideColorForPartScreenColors(partIndex: number): boolean;
	/**
	 * partのOverrideFlag setter関数
	 *
	 * @deprecated 名称変更のため非推奨 setOverrideColorForPartColors(
	 * partIndex: number,
	 * value: boolean,
	 * partColors: csmVector<PartColorData>,
	 * drawableColors: csmVector<DrawableColorData>) に置き換え
	 *
	 * @param partIndex partのインデックス
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 * @param partColors 設定するpartのカラーデータ配列
	 * @param drawableColors partに関連するDrawableのカラーデータ配列
	 */
	setOverwriteColorForPartColors(partIndex: number, value: boolean, partColors: csmVector<PartColorData>, drawableColors: csmVector<DrawableColorData>): void;
	/**
	 * partのOverrideFlag setter関数
	 * @param partIndex partのインデックス
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 * @param partColors 設定するpartのカラーデータ配列
	 * @param drawableColors partに関連するDrawableのカラーデータ配列
	 */
	setOverrideColorForPartColors(partIndex: number, value: boolean, partColors: csmVector<PartColorData>, drawableColors: csmVector<DrawableColorData>): void;
	/**
	 * SDKからpartのスクリーン色を上書きするかをセットする
	 *
	 * @deprecated 名称変更のため非推奨 setOverrideColorForPartMultiplyColors(partIndex: number, value: boolean) に置き換え
	 *
	 * @param partIndex partのインデックス
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverwriteColorForPartMultiplyColors(partIndex: number, value: boolean): void;
	/**
	 * SDKからpartのスクリーン色を上書きするかをセットする
	 * @param partIndex partのインデックス
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverrideColorForPartMultiplyColors(partIndex: number, value: boolean): void;
	/**
	 * SDKからpartのスクリーン色を上書きするかをセットする
	 *
	 * @deprecated 名称変更のため非推奨 setOverrideColorForPartScreenColors(partIndex: number, value: boolean) に置き換え
	 *
	 * @param partIndex partのインデックス
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverwriteColorForPartScreenColors(partIndex: number, value: boolean): void;
	/**
	 * SDKからpartのスクリーン色を上書きするかをセットする
	 * @param partIndex partのインデックス
	 * @param value true -> SDKからの情報を優先する
	 *              false -> モデルに設定されている色情報を使用
	 */
	setOverrideColorForPartScreenColors(partIndex: number, value: boolean): void;
	/**
	 * Drawableのカリング情報を取得する。
	 *
	 * @param   drawableIndex   Drawableのインデックス
	 * @return  Drawableのカリング情報
	 */
	getDrawableCulling(drawableIndex: number): boolean;
	/**
	 * Drawableのカリング情報を設定する。
	 *
	 * @param drawableIndex Drawableのインデックス
	 * @param isCulling カリング情報
	 */
	setDrawableCulling(drawableIndex: number, isCulling: boolean): void;
	/**
	 * SDKからモデル全体のカリング設定を上書きするか。
	 *
	 * @deprecated 名称変更のため非推奨 getOverrideFlagForModelCullings() に置き換え
	 *
	 * @retval  true    ->  SDK上のカリング設定を使用
	 * @retval  false   ->  モデルのカリング設定を使用
	 */
	getOverwriteFlagForModelCullings(): boolean;
	/**
	 * SDKからモデル全体のカリング設定を上書きするか。
	 *
	 * @retval  true    ->  SDK上のカリング設定を使用
	 * @retval  false   ->  モデルのカリング設定を使用
	 */
	getOverrideFlagForModelCullings(): boolean;
	/**
	 * SDKからモデル全体のカリング設定を上書きするかを設定する。
	 *
	 * @deprecated 名称変更のため非推奨 setOverrideFlagForModelCullings(isOverriddenCullings: boolean) に置き換え
	 *
	 * @param isOveriddenCullings SDK上のカリング設定を使うならtrue、モデルのカリング設定を使うならfalse
	 */
	setOverwriteFlagForModelCullings(isOverriddenCullings: boolean): void;
	/**
	 * SDKからモデル全体のカリング設定を上書きするかを設定する。
	 *
	 * @param isOverriddenCullings SDK上のカリング設定を使うならtrue、モデルのカリング設定を使うならfalse
	 */
	setOverrideFlagForModelCullings(isOverriddenCullings: boolean): void;
	/**
	 *
	 * @deprecated 名称変更のため非推奨 getOverrideFlagForDrawableCullings(drawableIndex: number) に置き換え
	 *
	 * @param drawableIndex Drawableのインデックス
	 * @retval  true    ->  SDK上のカリング設定を使用
	 * @retval  false   ->  モデルのカリング設定を使用
	 */
	getOverwriteFlagForDrawableCullings(drawableIndex: number): boolean;
	/**
	 *
	 * @param drawableIndex Drawableのインデックス
	 * @retval  true    ->  SDK上のカリング設定を使用
	 * @retval  false   ->  モデルのカリング設定を使用
	 */
	getOverrideFlagForDrawableCullings(drawableIndex: number): boolean;
	/**
	 *
	 * @deprecated 名称変更のため非推奨 setOverrideFlagForDrawableCullings(drawableIndex: number, isOverriddenCullings: bolean) に置き換え
	 *
	 * @param drawableIndex Drawableのインデックス
	 * @param isOverriddenCullings SDK上のカリング設定を使うならtrue、モデルのカリング設定を使うならfalse
	 */
	setOverwriteFlagForDrawableCullings(drawableIndex: number, isOverriddenCullings: boolean): void;
	/**
	 *
	 * @param drawableIndex Drawableのインデックス
	 * @param isOverriddenCullings SDK上のカリング設定を使うならtrue、モデルのカリング設定を使うならfalse
	 */
	setOverrideFlagForDrawableCullings(drawableIndex: number, isOverriddenCullings: boolean): void;
	/**
	 * モデルの不透明度を取得する
	 *
	 * @returns 不透明度の値
	 */
	getModelOapcity(): number;
	/**
	 * モデルの不透明度を設定する
	 *
	 * @param value 不透明度の値
	 */
	setModelOapcity(value: number): void;
	/**
	 * モデルを取得
	 */
	getModel(): Live2DCubismCore.Model;
	/**
	 * パーツのインデックスを取得
	 * @param partId パーツのID
	 * @return パーツのインデックス
	 */
	getPartIndex(partId: CubismIdHandle): number;
	/**
	 * パーツのIDを取得する。
	 *
	 * @param partIndex 取得するパーツのインデックス
	 * @return パーツのID
	 */
	getPartId(partIndex: number): CubismIdHandle;
	/**
	 * パーツの個数の取得
	 * @return パーツの個数
	 */
	getPartCount(): number;
	/**
	 * パーツの親パーツインデックスのリストを取得
	 *
	 * @returns パーツの親パーツインデックスのリスト
	 */
	getPartParentPartIndices(): Int32Array;
	/**
	 * パーツの不透明度の設定(Index)
	 * @param partIndex パーツのインデックス
	 * @param opacity 不透明度
	 */
	setPartOpacityByIndex(partIndex: number, opacity: number): void;
	/**
	 * パーツの不透明度の設定(Id)
	 * @param partId パーツのID
	 * @param opacity パーツの不透明度
	 */
	setPartOpacityById(partId: CubismIdHandle, opacity: number): void;
	/**
	 * パーツの不透明度の取得(index)
	 * @param partIndex パーツのインデックス
	 * @return パーツの不透明度
	 */
	getPartOpacityByIndex(partIndex: number): number;
	/**
	 * パーツの不透明度の取得(id)
	 * @param partId パーツのＩｄ
	 * @return パーツの不透明度
	 */
	getPartOpacityById(partId: CubismIdHandle): number;
	/**
	 * パラメータのインデックスの取得
	 * @param パラメータID
	 * @return パラメータのインデックス
	 */
	getParameterIndex(parameterId: CubismIdHandle): number;
	/**
	 * パラメータの個数の取得
	 * @return パラメータの個数
	 */
	getParameterCount(): number;
	/**
	 * パラメータの種類の取得
	 * @param parameterIndex パラメータのインデックス
	 * @return csmParameterType_Normal -> 通常のパラメータ
	 *          csmParameterType_BlendShape -> ブレンドシェイプパラメータ
	 */
	getParameterType(parameterIndex: number): Live2DCubismCore.csmParameterType;
	/**
	 * パラメータの最大値の取得
	 * @param parameterIndex パラメータのインデックス
	 * @return パラメータの最大値
	 */
	getParameterMaximumValue(parameterIndex: number): number;
	/**
	 * パラメータの最小値の取得
	 * @param parameterIndex パラメータのインデックス
	 * @return パラメータの最小値
	 */
	getParameterMinimumValue(parameterIndex: number): number;
	/**
	 * パラメータのデフォルト値の取得
	 * @param parameterIndex パラメータのインデックス
	 * @return パラメータのデフォルト値
	 */
	getParameterDefaultValue(parameterIndex: number): number;
	/**
	 * 指定したパラメータindexのIDを取得
	 *
	 * @param parameterIndex パラメータのインデックス
	 * @returns パラメータID
	 */
	getParameterId(parameterIndex: number): CubismIdHandle;
	/**
	 * パラメータの値の取得
	 * @param parameterIndex    パラメータのインデックス
	 * @return パラメータの値
	 */
	getParameterValueByIndex(parameterIndex: number): number;
	/**
	 * パラメータの値の取得
	 * @param parameterId    パラメータのID
	 * @return パラメータの値
	 */
	getParameterValueById(parameterId: CubismIdHandle): number;
	/**
	 * パラメータの値の設定
	 * @param parameterIndex パラメータのインデックス
	 * @param value パラメータの値
	 * @param weight 重み
	 */
	setParameterValueByIndex(parameterIndex: number, value: number, weight?: number): void;
	/**
	 * パラメータの値の設定
	 * @param parameterId パラメータのID
	 * @param value パラメータの値
	 * @param weight 重み
	 */
	setParameterValueById(parameterId: CubismIdHandle, value: number, weight?: number): void;
	/**
	 * パラメータの値の加算(index)
	 * @param parameterIndex パラメータインデックス
	 * @param value 加算する値
	 * @param weight 重み
	 */
	addParameterValueByIndex(parameterIndex: number, value: number, weight?: number): void;
	/**
	 * パラメータの値の加算(id)
	 * @param parameterId パラメータＩＤ
	 * @param value 加算する値
	 * @param weight 重み
	 */
	addParameterValueById(parameterId: any, value: number, weight?: number): void;
	/**
	 * Gets whether the parameter has the repeat setting.
	 *
	 * @param parameterIndex Parameter index
	 *
	 * @return true if it is set, otherwise returns false.
	 */
	isRepeat(parameterIndex: number): boolean;
	/**
	 * Returns the calculated result ensuring the value falls within the parameter's range.
	 *
	 * @param parameterIndex Parameter index
	 * @param value Parameter value
	 *
	 * @return a value that falls within the parameter’s range. If the parameter does not exist, returns it as is.
	 */
	getParameterRepeatValue(parameterIndex: number, value: number): number;
	/**
	 * Returns the result of clamping the value to ensure it falls within the parameter's range.
	 *
	 * @param parameterIndex Parameter index
	 * @param value Parameter value
	 *
	 * @return the clamped value. If the parameter does not exist, returns it as is.
	 */
	getParameterClampValue(parameterIndex: number, value: number): number;
	/**
	 * Returns the repeat of the parameter.
	 *
	 * @param parameterIndex Parameter index
	 *
	 * @return the raw data parameter repeat from the Cubism Core.
	 */
	getParameterRepeats(parameterIndex: number): boolean;
	/**
	 * パラメータの値の乗算
	 * @param parameterId パラメータのID
	 * @param value 乗算する値
	 * @param weight 重み
	 */
	multiplyParameterValueById(parameterId: CubismIdHandle, value: number, weight?: number): void;
	/**
	 * パラメータの値の乗算
	 * @param parameterIndex パラメータのインデックス
	 * @param value 乗算する値
	 * @param weight 重み
	 */
	multiplyParameterValueByIndex(parameterIndex: number, value: number, weight?: number): void;
	/**
	 * Drawableのインデックスの取得
	 * @param drawableId DrawableのID
	 * @return Drawableのインデックス
	 */
	getDrawableIndex(drawableId: CubismIdHandle): number;
	/**
	 * Drawableの個数の取得
	 * @return drawableの個数
	 */
	getDrawableCount(): number;
	/**
	 * DrawableのIDを取得する
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableのID
	 */
	getDrawableId(drawableIndex: number): CubismIdHandle;
	/**
	 * Drawableの描画順リストの取得
	 * @return Drawableの描画順リスト
	 */
	getDrawableRenderOrders(): Int32Array;
	/**
	 * @deprecated
	 * 関数名が誤っていたため、代替となる getDrawableTextureIndex を追加し、この関数は非推奨となりました。
	 *
	 * Drawableのテクスチャインデックスリストの取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableのテクスチャインデックスリスト
	 */
	getDrawableTextureIndices(drawableIndex: number): number;
	/**
	 * Drawableのテクスチャインデックスの取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableのテクスチャインデックス
	 */
	getDrawableTextureIndex(drawableIndex: number): number;
	/**
	 * DrawableのVertexPositionsの変化情報の取得
	 *
	 * 直近のCubismModel.update関数でDrawableの頂点情報が変化したかを取得する。
	 *
	 * @param   drawableIndex   Drawableのインデックス
	 * @retval  true    Drawableの頂点情報が直近のCubismModel.update関数で変化した
	 * @retval  false   Drawableの頂点情報が直近のCubismModel.update関数で変化していない
	 */
	getDrawableDynamicFlagVertexPositionsDidChange(drawableIndex: number): boolean;
	/**
	 * Drawableの頂点インデックスの個数の取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableの頂点インデックスの個数
	 */
	getDrawableVertexIndexCount(drawableIndex: number): number;
	/**
	 * Drawableの頂点の個数の取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableの頂点の個数
	 */
	getDrawableVertexCount(drawableIndex: number): number;
	/**
	 * Drawableの頂点リストの取得
	 * @param drawableIndex drawableのインデックス
	 * @return drawableの頂点リスト
	 */
	getDrawableVertices(drawableIndex: number): Float32Array;
	/**
	 * Drawableの頂点インデックスリストの取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableの頂点インデックスリスト
	 */
	getDrawableVertexIndices(drawableIndex: number): Uint16Array;
	/**
	 * Drawableの頂点リストの取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableの頂点リスト
	 */
	getDrawableVertexPositions(drawableIndex: number): Float32Array;
	/**
	 * Drawableの頂点のUVリストの取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableの頂点UVリスト
	 */
	getDrawableVertexUvs(drawableIndex: number): Float32Array;
	/**
	 * Drawableの不透明度の取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableの不透明度
	 */
	getDrawableOpacity(drawableIndex: number): number;
	/**
	 * Drawableの乗算色の取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableの乗算色(RGBA)
	 * スクリーン色はRGBAで取得されるが、Aは必ず0
	 */
	getDrawableMultiplyColor(drawableIndex: number): CubismTextureColor;
	/**
	 * Drawableのスクリーン色の取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableのスクリーン色(RGBA)
	 * スクリーン色はRGBAで取得されるが、Aは必ず0
	 */
	getDrawableScreenColor(drawableIndex: number): CubismTextureColor;
	/**
	 * Drawableの親パーツのインデックスの取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableの親パーツのインデックス
	 */
	getDrawableParentPartIndex(drawableIndex: number): number;
	/**
	 * Drawableのブレンドモードを取得
	 * @param drawableIndex Drawableのインデックス
	 * @return drawableのブレンドモード
	 */
	getDrawableBlendMode(drawableIndex: number): CubismBlendMode;
	/**
	 * Drawableのマスクの反転使用の取得
	 *
	 * Drawableのマスク使用時の反転設定を取得する。
	 * マスクを使用しない場合は無視される。
	 *
	 * @param drawableIndex Drawableのインデックス
	 * @return Drawableの反転設定
	 */
	getDrawableInvertedMaskBit(drawableIndex: number): boolean;
	/**
	 * Drawableのクリッピングマスクリストの取得
	 * @return Drawableのクリッピングマスクリスト
	 */
	getDrawableMasks(): Int32Array[];
	/**
	 * Drawableのクリッピングマスクの個数リストの取得
	 * @return Drawableのクリッピングマスクの個数リスト
	 */
	getDrawableMaskCounts(): Int32Array;
	/**
	 * クリッピングマスクの使用状態
	 *
	 * @return true クリッピングマスクを使用している
	 * @return false クリッピングマスクを使用していない
	 */
	isUsingMasking(): boolean;
	/**
	 * Drawableの表示情報を取得する
	 *
	 * @param drawableIndex Drawableのインデックス
	 * @return true Drawableが表示
	 * @return false Drawableが非表示
	 */
	getDrawableDynamicFlagIsVisible(drawableIndex: number): boolean;
	/**
	 * DrawableのDrawOrderの変化情報の取得
	 *
	 * 直近のCubismModel.update関数でdrawableのdrawOrderが変化したかを取得する。
	 * drawOrderはartMesh上で指定する0から1000の情報
	 * @param drawableIndex drawableのインデックス
	 * @return true drawableの不透明度が直近のCubismModel.update関数で変化した
	 * @return false drawableの不透明度が直近のCubismModel.update関数で変化している
	 */
	getDrawableDynamicFlagVisibilityDidChange(drawableIndex: number): boolean;
	/**
	 * Drawableの不透明度の変化情報の取得
	 *
	 * 直近のCubismModel.update関数でdrawableの不透明度が変化したかを取得する。
	 *
	 * @param drawableIndex drawableのインデックス
	 * @return true Drawableの不透明度が直近のCubismModel.update関数で変化した
	 * @return false Drawableの不透明度が直近のCubismModel.update関数で変化してない
	 */
	getDrawableDynamicFlagOpacityDidChange(drawableIndex: number): boolean;
	/**
	 * Drawableの描画順序の変化情報の取得
	 *
	 * 直近のCubismModel.update関数でDrawableの描画の順序が変化したかを取得する。
	 *
	 * @param drawableIndex Drawableのインデックス
	 * @return true Drawableの描画の順序が直近のCubismModel.update関数で変化した
	 * @return false Drawableの描画の順序が直近のCubismModel.update関数で変化してない
	 */
	getDrawableDynamicFlagRenderOrderDidChange(drawableIndex: number): boolean;
	/**
	 * Drawableの乗算色・スクリーン色の変化情報の取得
	 *
	 * 直近のCubismModel.update関数でDrawableの乗算色・スクリーン色が変化したかを取得する。
	 *
	 * @param drawableIndex Drawableのインデックス
	 * @return true Drawableの乗算色・スクリーン色が直近のCubismModel.update関数で変化した
	 * @return false Drawableの乗算色・スクリーン色が直近のCubismModel.update関数で変化してない
	 */
	getDrawableDynamicFlagBlendColorDidChange(drawableIndex: number): boolean;
	/**
	 * 保存されたパラメータの読み込み
	 */
	loadParameters(): void;
	/**
	 * 初期化する
	 */
	initialize(): void;
	/**
	 * コンストラクタ
	 * @param model モデル
	 */
	constructor(model: Live2DCubismCore.Model);
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	private _notExistPartOpacities;
	private _notExistPartId;
	private _notExistParameterValues;
	private _notExistParameterId;
	private _savedParameters;
	/**
	 * Flag to determine whether to override model-wide parameter repeats on the SDK
	 */
	private _isOverriddenParameterRepeat;
	private _isOverriddenModelMultiplyColors;
	private _isOverriddenModelScreenColors;
	/**
	 * List to manage ParameterRepeat and Override flag to be set for each Parameter
	 */
	private _userParameterRepeatDataList;
	private _userMultiplyColors;
	private _userScreenColors;
	private _userPartScreenColors;
	private _userPartMultiplyColors;
	private _partChildDrawables;
	private _model;
	private _parameterValues;
	private _parameterMaximumValues;
	private _parameterMinimumValues;
	private _partOpacities;
	private _modelOpacity;
	private _parameterIds;
	private _partIds;
	private _drawableIds;
	private _isOverriddenCullings;
	private _userCullings;
}
declare class CubismBreath {
	/**
	 * インスタンスの作成
	 */
	static create(): CubismBreath;
	/**
	 * インスタンスの破棄
	 * @param instance 対象のCubismBreath
	 */
	static delete(instance: CubismBreath): void;
	/**
	 * 呼吸のパラメータの紐づけ
	 * @param breathParameters 呼吸を紐づけたいパラメータのリスト
	 */
	setParameters(breathParameters: csmVector<BreathParameterData>): void;
	/**
	 * 呼吸に紐づいているパラメータの取得
	 * @return 呼吸に紐づいているパラメータのリスト
	 */
	getParameters(): csmVector<BreathParameterData>;
	/**
	 * モデルのパラメータの更新
	 * @param model 対象のモデル
	 * @param deltaTimeSeconds デルタ時間[秒]
	 */
	updateParameters(model: CubismModel, deltaTimeSeconds: number): void;
	/**
	 * コンストラクタ
	 */
	constructor();
	_breathParameters: csmVector<BreathParameterData>;
	_currentTime: number;
}
declare class BreathParameterData {
	/**
	 * コンストラクタ
	 * @param parameterId   呼吸をひもづけるパラメータID
	 * @param offset        呼吸を正弦波としたときの、波のオフセット
	 * @param peak          呼吸を正弦波としたときの、波の高さ
	 * @param cycle         呼吸を正弦波としたときの、波の周期
	 * @param weight        パラメータへの重み
	 */
	constructor(parameterId?: CubismIdHandle, offset?: number, peak?: number, cycle?: number, weight?: number);
	parameterId: CubismIdHandle;
	offset: number;
	peak: number;
	cycle: number;
	weight: number;
}
declare class CubismEyeBlink {
	/**
	 * インスタンスを作成する
	 * @param modelSetting モデルの設定情報
	 * @return 作成されたインスタンス
	 * @note 引数がNULLの場合、パラメータIDが設定されていない空のインスタンスを作成する。
	 */
	static create(modelSetting?: ICubismModelSetting): CubismEyeBlink;
	/**
	 * インスタンスの破棄
	 * @param eyeBlink 対象のCubismEyeBlink
	 */
	static delete(eyeBlink: CubismEyeBlink): void;
	/**
	 * まばたきの間隔の設定
	 * @param blinkingInterval まばたきの間隔の時間[秒]
	 */
	setBlinkingInterval(blinkingInterval: number): void;
	/**
	 * まばたきのモーションの詳細設定
	 * @param closing   まぶたを閉じる動作の所要時間[秒]
	 * @param closed    まぶたを閉じている動作の所要時間[秒]
	 * @param opening   まぶたを開く動作の所要時間[秒]
	 */
	setBlinkingSetting(closing: number, closed: number, opening: number): void;
	/**
	 * まばたきさせるパラメータIDのリストの設定
	 * @param parameterIds パラメータのIDのリスト
	 */
	setParameterIds(parameterIds: csmVector<CubismIdHandle>): void;
	/**
	 * まばたきさせるパラメータIDのリストの取得
	 * @return パラメータIDのリスト
	 */
	getParameterIds(): csmVector<CubismIdHandle>;
	/**
	 * モデルのパラメータの更新
	 * @param model 対象のモデル
	 * @param deltaTimeSeconds デルタ時間[秒]
	 */
	updateParameters(model: CubismModel, deltaTimeSeconds: number): void;
	/**
	 * コンストラクタ
	 * @param modelSetting モデルの設定情報
	 */
	constructor(modelSetting: ICubismModelSetting);
	/**
	 * 次の瞬きのタイミングの決定
	 *
	 * @return 次のまばたきを行う時刻[秒]
	 */
	determinNextBlinkingTiming(): number;
	_blinkingState: number;
	_parameterIds: csmVector<CubismIdHandle>;
	_nextBlinkingTime: number;
	_stateStartTimeSeconds: number;
	_blinkingIntervalSeconds: number;
	_closingSeconds: number;
	_closedSeconds: number;
	_openingSeconds: number;
	_userTimeSeconds: number;
	/**
	 * IDで指定された目のパラメータが、0のときに閉じるなら true 、1の時に閉じるなら false 。
	 */
	static readonly CloseIfZero: boolean;
}
declare enum EyeState {
	EyeState_First = 0,// 初期状態
	EyeState_Interval = 1,// まばたきしていない状態
	EyeState_Closing = 2,// まぶたが閉じていく途中の状態
	EyeState_Closed = 3,// まぶたが閉じている状態
	EyeState_Opening = 4
}
declare class CubismPose {
	/**
	 * インスタンスの作成
	 * @param pose3json pose3.jsonのデータ
	 * @param size pose3.jsonのデータのサイズ[byte]
	 * @return 作成されたインスタンス
	 */
	static create(pose3json: ArrayBuffer, size: number): CubismPose;
	/**
	 * インスタンスを破棄する
	 * @param pose 対象のCubismPose
	 */
	static delete(pose: CubismPose): void;
	/**
	 * モデルのパラメータの更新
	 * @param model 対象のモデル
	 * @param deltaTimeSeconds デルタ時間[秒]
	 */
	updateParameters(model: CubismModel, deltaTimeSeconds: number): void;
	/**
	 * 表示を初期化
	 * @param model 対象のモデル
	 * @note 不透明度の初期値が0でないパラメータは、不透明度を１に設定する
	 */
	reset(model: CubismModel): void;
	/**
	 * パーツの不透明度をコピー
	 *
	 * @param model 対象のモデル
	 */
	copyPartOpacities(model: CubismModel): void;
	/**
	 * パーツのフェード操作を行う。
	 * @param model 対象のモデル
	 * @param deltaTimeSeconds デルタ時間[秒]
	 * @param beginIndex フェード操作を行うパーツグループの先頭インデックス
	 * @param partGroupCount フェード操作を行うパーツグループの個数
	 */
	doFade(model: CubismModel, deltaTimeSeconds: number, beginIndex: number, partGroupCount: number): void;
	/**
	 * コンストラクタ
	 */
	constructor();
	_partGroups: csmVector<PartData>;
	_partGroupCounts: csmVector<number>;
	_fadeTimeSeconds: number;
	_lastModel: CubismModel;
}
declare class PartData {
	/**
	 * コンストラクタ
	 */
	constructor(v?: PartData);
	/**
	 * =演算子のオーバーロード
	 */
	assignment(v: PartData): PartData;
	/**
	 * 初期化
	 * @param model 初期化に使用するモデル
	 */
	initialize(model: CubismModel): void;
	/**
	 * オブジェクトのコピーを生成する
	 */
	clone(): PartData;
	partId: CubismIdHandle;
	parameterIndex: number;
	partIndex: number;
	link: csmVector<PartData>;
}
declare class CubismIdManager {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * ID名をリストから登録
	 *
	 * @param ids ID名リスト
	 * @param count IDの個数
	 */
	registerIds(ids: string[] | csmString[]): void;
	/**
	 * ID名を登録
	 *
	 * @param id ID名
	 */
	registerId(id: string | csmString): CubismId;
	/**
	 * ID名からIDを取得する
	 *
	 * @param id ID名
	 */
	getId(id: csmString | string): CubismId;
	/**
	 * ID名からIDの確認
	 *
	 * @return true 存在する
	 * @return false 存在しない
	 */
	isExist(id: csmString | string): boolean;
	/**
	 * ID名からIDを検索する。
	 *
	 * @param id ID名
	 * @return 登録されているID。なければNULL。
	 */
	private findId;
	private _ids;
}
declare function csmDelete<T>(address: T): void;
declare class CubismFramework {
	/**
	 * Cubism FrameworkのAPIを使用可能にする。
	 *  APIを実行する前に必ずこの関数を実行すること。
	 *  一度準備が完了して以降は、再び実行しても内部処理がスキップされます。
	 *
	 * @param    option      Optionクラスのインスタンス
	 *
	 * @return   準備処理が完了したらtrueが返ります。
	 */
	static startUp(option?: Option$1): boolean;
	/**
	 * StartUp()で初期化したCubismFrameworkの各パラメータをクリアします。
	 * Dispose()したCubismFrameworkを再利用する際に利用してください。
	 */
	static cleanUp(): void;
	/**
	 * Cubism Framework内のリソースを初期化してモデルを表示可能な状態にします。<br>
	 *     再度Initialize()するには先にDispose()を実行する必要があります。
	 *
	 * @param memorySize 初期化時メモリ量 [byte(s)]
	 *    複数モデル表示時などにモデルが更新されない際に使用してください。
	 *    指定する際は必ず1024*1024*16 byte(16MB)以上の値を指定してください。
	 *    それ以外はすべて1024*1024*16 byteに丸めます。
	 */
	static initialize(memorySize?: number): void;
	/**
	 * Cubism Framework内の全てのリソースを解放します。
	 *      ただし、外部で確保されたリソースについては解放しません。
	 *      外部で適切に破棄する必要があります。
	 */
	static dispose(): void;
	/**
	 * Cubism FrameworkのAPIを使用する準備が完了したかどうか
	 * @return APIを使用する準備が完了していればtrueが返ります。
	 */
	static isStarted(): boolean;
	/**
	 * Cubism Frameworkのリソース初期化がすでに行われているかどうか
	 * @return リソース確保が完了していればtrueが返ります
	 */
	static isInitialized(): boolean;
	/**
	 * Core APIにバインドしたログ関数を実行する
	 *
	 * @praram message ログメッセージ
	 */
	static coreLogFunction(message: string): void;
	/**
	 * 現在のログ出力レベル設定の値を返す。
	 *
	 * @return  現在のログ出力レベル設定の値
	 */
	static getLoggingLevel(): LogLevel;
	/**
	 * IDマネージャのインスタンスを取得する
	 * @return CubismManagerクラスのインスタンス
	 */
	static getIdManager(): CubismIdManager;
	/**
	 * 静的クラスとして使用する
	 * インスタンス化させない
	 */
	private constructor();
}
declare class Option$1 {
	logFunction: Live2DCubismCore.csmLogFunction;
	loggingLevel: LogLevel;
}
declare enum LogLevel {
	LogLevel_Verbose = 0,// 詳細ログ
	LogLevel_Debug = 1,// デバッグログ
	LogLevel_Info = 2,// Infoログ
	LogLevel_Warning = 3,// 警告ログ
	LogLevel_Error = 4,// エラーログ
	LogLevel_Off = 5
}
declare namespace Live2DCubismFramework {
	const Constant: Readonly<Record<string, number>>;
	const csmDelete: typeof csmDelete;
	const CubismFramework: typeof CubismFramework;
	type CubismFramework = CubismFramework;
}
declare class CubismVector2 {
	x?: number;
	y?: number;
	/**
	 * コンストラクタ
	 */
	constructor(x?: number, y?: number);
	/**
	 * ベクトルの加算
	 *
	 * @param vector2 加算するベクトル値
	 * @return 加算結果 ベクトル値
	 */
	add(vector2: CubismVector2): CubismVector2;
	/**
	 * ベクトルの減算
	 *
	 * @param vector2 減算するベクトル値
	 * @return 減算結果 ベクトル値
	 */
	substract(vector2: CubismVector2): CubismVector2;
	/**
	 * ベクトルの乗算
	 *
	 * @param vector2 乗算するベクトル値
	 * @return 乗算結果 ベクトル値
	 */
	multiply(vector2: CubismVector2): CubismVector2;
	/**
	 * ベクトルの乗算(スカラー)
	 *
	 * @param scalar 乗算するスカラー値
	 * @return 乗算結果 ベクトル値
	 */
	multiplyByScaler(scalar: number): CubismVector2;
	/**
	 * ベクトルの除算
	 *
	 * @param vector2 除算するベクトル値
	 * @return 除算結果 ベクトル値
	 */
	division(vector2: CubismVector2): CubismVector2;
	/**
	 * ベクトルの除算(スカラー)
	 *
	 * @param scalar 除算するスカラー値
	 * @return 除算結果 ベクトル値
	 */
	divisionByScalar(scalar: number): CubismVector2;
	/**
	 * ベクトルの長さを取得する
	 *
	 * @return ベクトルの長さ
	 */
	getLength(): number;
	/**
	 * ベクトルの距離の取得
	 *
	 * @param a 点
	 * @return ベクトルの距離
	 */
	getDistanceWith(a: CubismVector2): number;
	/**
	 * ドット積の計算
	 *
	 * @param a 値
	 * @return 結果
	 */
	dot(a: CubismVector2): number;
	/**
	 * 正規化の適用
	 */
	normalize(): void;
	/**
	 * 等しさの確認（等しいか？）
	 *
	 * 値が等しいか？
	 *
	 * @param rhs 確認する値
	 * @return true 値は等しい
	 * @return false 値は等しくない
	 */
	isEqual(rhs: CubismVector2): boolean;
	/**
	 * 等しさの確認（等しくないか？）
	 *
	 * 値が等しくないか？
	 *
	 * @param rhs 確認する値
	 * @return true 値は等しくない
	 * @return false 値は等しい
	 */
	isNotEqual(rhs: CubismVector2): boolean;
}
declare class CubismMath {
	static readonly Epsilon: number;
	/**
	 * 第一引数の値を最小値と最大値の範囲に収めた値を返す
	 *
	 * @param value 収められる値
	 * @param min   範囲の最小値
	 * @param max   範囲の最大値
	 * @return 最小値と最大値の範囲に収めた値
	 */
	static range(value: number, min: number, max: number): number;
	/**
	 * サイン関数の値を求める
	 *
	 * @param x 角度値（ラジアン）
	 * @return サイン関数sin(x)の値
	 */
	static sin(x: number): number;
	/**
	 * コサイン関数の値を求める
	 *
	 * @param x 角度値(ラジアン)
	 * @return コサイン関数cos(x)の値
	 */
	static cos(x: number): number;
	/**
	 * 値の絶対値を求める
	 *
	 * @param x 絶対値を求める値
	 * @return 値の絶対値
	 */
	static abs(x: number): number;
	/**
	 * 平方根(ルート)を求める
	 * @param x -> 平方根を求める値
	 * @return 値の平方根
	 */
	static sqrt(x: number): number;
	/**
	 * 立方根を求める
	 * @param x -> 立方根を求める値
	 * @return 値の立方根
	 */
	static cbrt(x: number): number;
	/**
	 * イージング処理されたサインを求める
	 * フェードイン・アウト時のイージングに利用できる
	 *
	 * @param value イージングを行う値
	 * @return イージング処理されたサイン値
	 */
	static getEasingSine(value: number): number;
	/**
	 * 大きい方の値を返す
	 *
	 * @param left 左辺の値
	 * @param right 右辺の値
	 * @return 大きい方の値
	 */
	static max(left: number, right: number): number;
	/**
	 * 小さい方の値を返す
	 *
	 * @param left  左辺の値
	 * @param right 右辺の値
	 * @return 小さい方の値
	 */
	static min(left: number, right: number): number;
	static clamp(val: number, min: number, max: number): number;
	/**
	 * 角度値をラジアン値に変換する
	 *
	 * @param degrees   角度値
	 * @return 角度値から変換したラジアン値
	 */
	static degreesToRadian(degrees: number): number;
	/**
	 * ラジアン値を角度値に変換する
	 *
	 * @param radian    ラジアン値
	 * @return ラジアン値から変換した角度値
	 */
	static radianToDegrees(radian: number): number;
	/**
	 * ２つのベクトルからラジアン値を求める
	 *
	 * @param from  始点ベクトル
	 * @param to    終点ベクトル
	 * @return ラジアン値から求めた方向ベクトル
	 */
	static directionToRadian(from: CubismVector2, to: CubismVector2): number;
	/**
	 * ２つのベクトルから角度値を求める
	 *
	 * @param from  始点ベクトル
	 * @param to    終点ベクトル
	 * @return 角度値から求めた方向ベクトル
	 */
	static directionToDegrees(from: CubismVector2, to: CubismVector2): number;
	/**
	 * ラジアン値を方向ベクトルに変換する。
	 *
	 * @param totalAngle    ラジアン値
	 * @return ラジアン値から変換した方向ベクトル
	 */
	static radianToDirection(totalAngle: number): CubismVector2;
	/**
	 * 三次方程式の三次項の係数が0になったときに補欠的に二次方程式の解をもとめる。
	 * a * x^2 + b * x + c = 0
	 *
	 * @param   a -> 二次項の係数値
	 * @param   b -> 一次項の係数値
	 * @param   c -> 定数項の値
	 * @return  二次方程式の解
	 */
	static quadraticEquation(a: number, b: number, c: number): number;
	/**
	 * カルダノの公式によってベジェのt値に該当する３次方程式の解を求める。
	 * 重解になったときには0.0～1.0の値になる解を返す。
	 *
	 * a * x^3 + b * x^2 + c * x + d = 0
	 *
	 * @param   a -> 三次項の係数値
	 * @param   b -> 二次項の係数値
	 * @param   c -> 一次項の係数値
	 * @param   d -> 定数項の値
	 * @return  0.0～1.0の間にある解
	 */
	static cardanoAlgorithmForBezier(a: number, b: number, c: number, d: number): number;
	/**
	 * 浮動小数点の余りを求める。
	 *
	 * @param dividend 被除数（割られる値）
	 * @param divisor 除数（割る値）
	 * @returns 余り
	 */
	static mod(dividend: number, divisor: number): number;
	/**
	 * コンストラクタ
	 */
	private constructor();
}
declare class CubismModelMatrix extends CubismMatrix44 {
	/**
	 * コンストラクタ
	 *
	 * @param w 横幅
	 * @param h 縦幅
	 */
	constructor(w?: number, h?: number);
	/**
	 * 横幅を設定
	 *
	 * @param w 横幅
	 */
	setWidth(w: number): void;
	/**
	 * 縦幅を設定
	 * @param h 縦幅
	 */
	setHeight(h: number): void;
	/**
	 * 位置を設定
	 *
	 * @param x X軸の位置
	 * @param y Y軸の位置
	 */
	setPosition(x: number, y: number): void;
	/**
	 * 中心位置を設定
	 *
	 * @param x X軸の中心位置
	 * @param y Y軸の中心位置
	 *
	 * @note widthかheightを設定したあとでないと、拡大率が正しく取得できないためずれる。
	 */
	setCenterPosition(x: number, y: number): void;
	/**
	 * 上辺の位置を設定する
	 *
	 * @param y 上辺のY軸位置
	 */
	top(y: number): void;
	/**
	 * 下辺の位置を設定する
	 *
	 * @param y 下辺のY軸位置
	 */
	bottom(y: number): void;
	/**
	 * 左辺の位置を設定
	 *
	 * @param x 左辺のX軸位置
	 */
	left(x: number): void;
	/**
	 * 右辺の位置を設定
	 *
	 * @param x 右辺のX軸位置
	 */
	right(x: number): void;
	/**
	 * X軸の中心位置を設定
	 *
	 * @param x X軸の中心位置
	 */
	centerX(x: number): void;
	/**
	 * X軸の位置を設定
	 *
	 * @param x X軸の位置
	 */
	setX(x: number): void;
	/**
	 * Y軸の中心位置を設定
	 *
	 * @param y Y軸の中心位置
	 */
	centerY(y: number): void;
	/**
	 * Y軸の位置を設定する
	 *
	 * @param y Y軸の位置
	 */
	setY(y: number): void;
	/**
	 * レイアウト情報から位置を設定
	 *
	 * @param layout レイアウト情報
	 */
	setupFromLayout(layout: csmMap<string, number>): void;
	private _width;
	private _height;
}
declare class CubismTargetPoint {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * 更新処理
	 */
	update(deltaTimeSeconds: number): void;
	/**
	 * X軸の顔の向きの値を取得
	 *
	 * @return X軸の顔の向きの値（-1.0 ~ 1.0）
	 */
	getX(): number;
	/**
	 * Y軸の顔の向きの値を取得
	 *
	 * @return Y軸の顔の向きの値（-1.0 ~ 1.0）
	 */
	getY(): number;
	/**
	 * 顔の向きの目標値を設定
	 *
	 * @param x X軸の顔の向きの値（-1.0 ~ 1.0）
	 * @param y Y軸の顔の向きの値（-1.0 ~ 1.0）
	 */
	set(x: number, y: number): void;
	private _faceTargetX;
	private _faceTargetY;
	private _faceX;
	private _faceY;
	private _faceVX;
	private _faceVY;
	private _lastTimeSeconds;
	private _userTimeSeconds;
}
declare class CubismViewMatrix extends CubismMatrix44 {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * 移動を調整
	 *
	 * @param x X軸の移動量
	 * @param y Y軸の移動量
	 */
	adjustTranslate(x: number, y: number): void;
	/**
	 * 拡大率を調整
	 *
	 * @param cx 拡大を行うX軸の中心位置
	 * @param cy 拡大を行うY軸の中心位置
	 * @param scale 拡大率
	 */
	adjustScale(cx: number, cy: number, scale: number): void;
	/**
	 * デバイスに対応する論理座養生の範囲の設定
	 *
	 * @param left      左辺のX軸の位置
	 * @param right     右辺のX軸の位置
	 * @param bottom    下辺のY軸の位置
	 * @param top       上辺のY軸の位置
	 */
	setScreenRect(left: number, right: number, bottom: number, top: number): void;
	/**
	 * デバイスに対応する論理座標上の移動可能範囲の設定
	 * @param left      左辺のX軸の位置
	 * @param right     右辺のX軸の位置
	 * @param bottom    下辺のY軸の位置
	 * @param top       上辺のY軸の位置
	 */
	setMaxScreenRect(left: number, right: number, bottom: number, top: number): void;
	/**
	 * 最大拡大率の設定
	 * @param maxScale 最大拡大率
	 */
	setMaxScale(maxScale: number): void;
	/**
	 * 最小拡大率の設定
	 * @param minScale 最小拡大率
	 */
	setMinScale(minScale: number): void;
	/**
	 * 最大拡大率の取得
	 * @return 最大拡大率
	 */
	getMaxScale(): number;
	/**
	 * 最小拡大率の取得
	 * @return 最小拡大率
	 */
	getMinScale(): number;
	/**
	 * 拡大率が最大になっているかを確認する
	 *
	 * @return true 拡大率は最大
	 * @return false 拡大率は最大ではない
	 */
	isMaxScale(): boolean;
	/**
	 * 拡大率が最小になっているかを確認する
	 *
	 * @return true 拡大率は最小
	 * @return false 拡大率は最小ではない
	 */
	isMinScale(): boolean;
	/**
	 * デバイスに対応する論理座標の左辺のＸ軸位置を取得する
	 * @return デバイスに対応する論理座標の左辺のX軸位置
	 */
	getScreenLeft(): number;
	/**
	 * デバイスに対応する論理座標の右辺のＸ軸位置を取得する
	 * @return デバイスに対応する論理座標の右辺のX軸位置
	 */
	getScreenRight(): number;
	/**
	 * デバイスに対応する論理座標の下辺のY軸位置を取得する
	 * @return デバイスに対応する論理座標の下辺のY軸位置
	 */
	getScreenBottom(): number;
	/**
	 * デバイスに対応する論理座標の上辺のY軸位置を取得する
	 * @return デバイスに対応する論理座標の上辺のY軸位置
	 */
	getScreenTop(): number;
	/**
	 * 左辺のX軸位置の最大値の取得
	 * @return 左辺のX軸位置の最大値
	 */
	getMaxLeft(): number;
	/**
	 * 右辺のX軸位置の最大値の取得
	 * @return 右辺のX軸位置の最大値
	 */
	getMaxRight(): number;
	/**
	 * 下辺のY軸位置の最大値の取得
	 * @return 下辺のY軸位置の最大値
	 */
	getMaxBottom(): number;
	/**
	 * 上辺のY軸位置の最大値の取得
	 * @return 上辺のY軸位置の最大値
	 */
	getMaxTop(): number;
	private _screenLeft;
	private _screenRight;
	private _screenTop;
	private _screenBottom;
	private _maxLeft;
	private _maxRight;
	private _maxTop;
	private _maxBottom;
	private _maxScale;
	private _minScale;
}
declare class CubismMoc {
	/**
	 * Mocデータの作成
	 */
	static create(mocBytes: ArrayBuffer, shouldCheckMocConsistency: boolean): CubismMoc;
	/**
	 * Mocデータを削除
	 *
	 * Mocデータを削除する
	 */
	static delete(moc: CubismMoc): void;
	/**
	 * モデルを作成する
	 *
	 * @return Mocデータから作成されたモデル
	 */
	createModel(): CubismModel;
	/**
	 * モデルを削除する
	 */
	deleteModel(model: CubismModel): void;
	/**
	 * コンストラクタ
	 */
	private constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * 最新の.moc3 Versionを取得
	 */
	getLatestMocVersion(): number;
	/**
	 * 読み込んだモデルの.moc3 Versionを取得
	 */
	getMocVersion(): number;
	/**
	 * .moc3 の整合性を検証する
	 */
	static hasMocConsistency(mocBytes: ArrayBuffer): boolean;
	_moc: Live2DCubismCore.Moc;
	_modelCount: number;
	_mocVersion: number;
}
declare class CubismModelUserDataNode {
	targetType: CubismIdHandle;
	targetId: CubismIdHandle;
	value: csmString;
}
declare class CubismModelUserData {
	/**
	 * インスタンスの作成
	 *
	 * @param buffer    userdata3.jsonが読み込まれているバッファ
	 * @param size      バッファのサイズ
	 * @return 作成されたインスタンス
	 */
	static create(buffer: ArrayBuffer, size: number): CubismModelUserData;
	/**
	 * インスタンスを破棄する
	 *
	 * @param modelUserData 破棄するインスタンス
	 */
	static delete(modelUserData: CubismModelUserData): void;
	/**
	 * ArtMeshのユーザーデータのリストの取得
	 *
	 * @return ユーザーデータリスト
	 */
	getArtMeshUserDatas(): csmVector<CubismModelUserDataNode>;
	/**
	 * userdata3.jsonのパース
	 *
	 * @param buffer    userdata3.jsonが読み込まれているバッファ
	 * @param size      バッファのサイズ
	 */
	parseUserData(buffer: ArrayBuffer, size: number): void;
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 *
	 * ユーザーデータ構造体配列を解放する
	 */
	release(): void;
	private _userDataNodes;
	private _artMeshUserDataNode;
}
declare class CubismModelUserDataJson {
	/**
	 * コンストラクタ
	 * @param buffer    userdata3.jsonが読み込まれているバッファ
	 * @param size      バッファのサイズ
	 */
	constructor(buffer: ArrayBuffer, size: number);
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * ユーザーデータ個数の取得
	 * @return ユーザーデータの個数
	 */
	getUserDataCount(): number;
	/**
	 * ユーザーデータ総文字列数の取得
	 *
	 * @return ユーザーデータ総文字列数
	 */
	getTotalUserDataSize(): number;
	/**
	 * ユーザーデータのタイプの取得
	 *
	 * @return ユーザーデータのタイプ
	 */
	getUserDataTargetType(i: number): string;
	/**
	 * ユーザーデータのターゲットIDの取得
	 *
	 * @param i インデックス
	 * @return ユーザーデータターゲットID
	 */
	getUserDataId(i: number): CubismIdHandle;
	/**
	 * ユーザーデータの文字列の取得
	 *
	 * @param i インデックス
	 * @return ユーザーデータ
	 */
	getUserDataValue(i: number): string;
	private _json;
}
declare class CubismMotionQueueManager {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ
	 */
	release(): void;
	/**
	 * 指定したモーションの開始
	 *
	 * 指定したモーションを開始する。同じタイプのモーションが既にある場合は、既存のモーションに終了フラグを立て、フェードアウトを開始させる。
	 *
	 * @param   motion          開始するモーション
	 * @param   autoDelete      再生が終了したモーションのインスタンスを削除するなら true
	 * @param   userTimeSeconds Deprecated: デルタ時間の積算値[秒] 関数内で参照していないため使用は非推奨。
	 * @return                      開始したモーションの識別番号を返す。個別のモーションが終了したか否かを判定するIsFinished()の引数で使用する。開始できない時は「-1」
	 */
	startMotion(motion: ACubismMotion, autoDelete: boolean, userTimeSeconds?: number): CubismMotionQueueEntryHandle;
	/**
	 * 全てのモーションの終了の確認
	 * @return true 全て終了している
	 * @return false 終了していない
	 */
	isFinished(): boolean;
	/**
	 * 指定したモーションの終了の確認
	 * @param motionQueueEntryNumber モーションの識別番号
	 * @return true 全て終了している
	 * @return false 終了していない
	 */
	isFinishedByHandle(motionQueueEntryNumber: CubismMotionQueueEntryHandle): boolean;
	/**
	 * 全てのモーションを停止する
	 */
	stopAllMotions(): void;
	/**
	 * @brief CubismMotionQueueEntryの配列の取得
	 *
	 * CubismMotionQueueEntryの配列を取得する。
	 *
	 * @return  CubismMotionQueueEntryの配列へのポインタ
	 * @retval  NULL   見つからなかった
	 */
	getCubismMotionQueueEntries(): csmVector<CubismMotionQueueEntry>;
	/**
	 * 指定したCubismMotionQueueEntryの取得
  
	 * @param   motionQueueEntryNumber  モーションの識別番号
	 * @return  指定したCubismMotionQueueEntry
	 * @return  null   見つからなかった
	 */
	getCubismMotionQueueEntry(motionQueueEntryNumber: any): CubismMotionQueueEntry;
	/**
	 * イベントを受け取るCallbackの登録
	 *
	 * @param callback コールバック関数
	 * @param customData コールバックに返されるデータ
	 */
	setEventCallback(callback: CubismMotionEventFunction, customData?: any): void;
	/**
	 * モーションを更新して、モデルにパラメータ値を反映する。
	 *
	 * @param   model   対象のモデル
	 * @param   userTimeSeconds   デルタ時間の積算値[秒]
	 * @return  true    モデルへパラメータ値の反映あり
	 * @return  false   モデルへパラメータ値の反映なし(モーションの変化なし)
	 */
	doUpdateMotion(model: CubismModel, userTimeSeconds: number): boolean;
	_userTimeSeconds: number;
	_motions: csmVector<CubismMotionQueueEntry>;
	_eventCallBack: CubismMotionEventFunction;
	_eventCustomData: any;
}
/**
 * イベントのコールバック関数を定義
 *
 * イベントのコールバックに登録できる関数の型情報
 * @param caller        発火したイベントを再生させたCubismMotionQueueManager
 * @param eventValue    発火したイベントの文字列データ
 * @param customData   コールバックに返される登録時に指定されたデータ
 */
export interface CubismMotionEventFunction {
	(caller: CubismMotionQueueManager, eventValue: csmString, customData: any): void;
}
/**
 * モーションの識別番号
 *
 * モーションの識別番号の定義
 */
export declare type CubismMotionQueueEntryHandle = any;
declare const InvalidMotionQueueEntryHandleValue: CubismMotionQueueEntryHandle;
declare class CubismMotionQueueEntry {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * フェードアウト時間と開始判定の設定
	 * @param fadeOutSeconds フェードアウトにかかる時間[秒]
	 */
	setFadeOut(fadeOutSeconds: number): void;
	/**
	 * フェードアウトの開始
	 * @param fadeOutSeconds フェードアウトにかかる時間[秒]
	 * @param userTimeSeconds デルタ時間の積算値[秒]
	 */
	startFadeOut(fadeOutSeconds: number, userTimeSeconds: number): void;
	/**
	 * モーションの終了の確認
	 *
	 * @return true モーションが終了した
	 * @return false 終了していない
	 */
	isFinished(): boolean;
	/**
	 * モーションの開始の確認
	 * @return true モーションが開始した
	 * @return false 開始していない
	 */
	isStarted(): boolean;
	/**
	 * モーションの開始時刻の取得
	 * @return モーションの開始時刻[秒]
	 */
	getStartTime(): number;
	/**
	 * フェードインの開始時刻の取得
	 * @return フェードインの開始時刻[秒]
	 */
	getFadeInStartTime(): number;
	/**
	 * フェードインの終了時刻の取得
	 * @return フェードインの終了時刻の取得
	 */
	getEndTime(): number;
	/**
	 * モーションの開始時刻の設定
	 * @param startTime モーションの開始時刻
	 */
	setStartTime(startTime: number): void;
	/**
	 * フェードインの開始時刻の設定
	 * @param startTime フェードインの開始時刻[秒]
	 */
	setFadeInStartTime(startTime: number): void;
	/**
	 * フェードインの終了時刻の設定
	 * @param endTime フェードインの終了時刻[秒]
	 */
	setEndTime(endTime: number): void;
	/**
	 * モーションの終了の設定
	 * @param f trueならモーションの終了
	 */
	setIsFinished(f: boolean): void;
	/**
	 * モーション開始の設定
	 * @param f trueならモーションの開始
	 */
	setIsStarted(f: boolean): void;
	/**
	 * モーションの有効性の確認
	 * @return true モーションは有効
	 * @return false モーションは無効
	 */
	isAvailable(): boolean;
	/**
	 * モーションの有効性の設定
	 * @param v trueならモーションは有効
	 */
	setIsAvailable(v: boolean): void;
	/**
	 * モーションの状態の設定
	 * @param timeSeconds 現在時刻[秒]
	 * @param weight モーション尾重み
	 */
	setState(timeSeconds: number, weight: number): void;
	/**
	 * モーションの現在時刻の取得
	 * @return モーションの現在時刻[秒]
	 */
	getStateTime(): number;
	/**
	 * モーションの重みの取得
	 * @return モーションの重み
	 */
	getStateWeight(): number;
	/**
	 * 最後にイベントの発火をチェックした時間を取得
	 *
	 * @return 最後にイベントの発火をチェックした時間[秒]
	 */
	getLastCheckEventSeconds(): number;
	/**
	 * 最後にイベントをチェックした時間を設定
	 * @param checkSeconds 最後にイベントをチェックした時間[秒]
	 */
	setLastCheckEventSeconds(checkSeconds: number): void;
	/**
	 * フェードアウト開始判定の取得
	 * @return フェードアウト開始するかどうか
	 */
	isTriggeredFadeOut(): boolean;
	/**
	 * フェードアウト時間の取得
	 * @return フェードアウト時間[秒]
	 */
	getFadeOutSeconds(): number;
	/**
	 * モーションの取得
	 *
	 * @return モーション
	 */
	getCubismMotion(): ACubismMotion;
	_autoDelete: boolean;
	_motion: ACubismMotion;
	_available: boolean;
	_finished: boolean;
	_started: boolean;
	_startTimeSeconds: number;
	_fadeInStartTimeSeconds: number;
	_endTimeSeconds: number;
	_stateTimeSeconds: number;
	_stateWeight: number;
	_lastEventCheckSeconds: number;
	private _fadeOutSeconds;
	private _isTriggeredFadeOut;
	_motionQueueEntryHandle: CubismMotionQueueEntryHandle;
}
/** モーション再生開始コールバック関数定義 */
export type BeganMotionCallback = (self: ACubismMotion) => void;
/** モーション再生終了コールバック関数定義 */
export type FinishedMotionCallback = (self: ACubismMotion) => void;
declare abstract class ACubismMotion {
	/**
	 * インスタンスの破棄
	 */
	static delete(motion: ACubismMotion): void;
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * モデルのパラメータ
	 * @param model 対象のモデル
	 * @param motionQueueEntry CubismMotionQueueManagerで管理されているモーション
	 * @param userTimeSeconds デルタ時間の積算値[秒]
	 */
	updateParameters(model: CubismModel, motionQueueEntry: CubismMotionQueueEntry, userTimeSeconds: number): void;
	/**
	 * @brief モデルの再生開始処理
	 *
	 * モーションの再生を開始するためのセットアップを行う。
	 *
	 * @param[in]   motionQueueEntry    CubismMotionQueueManagerで管理されているモーション
	 * @param[in]   userTimeSeconds     デルタ時間の積算値[秒]
	 */
	setupMotionQueueEntry(motionQueueEntry: CubismMotionQueueEntry, userTimeSeconds: number): void;
	/**
	 * @brief モデルのウェイト更新
	 *
	 * モーションのウェイトを更新する。
	 *
	 * @param[in]   motionQueueEntry    CubismMotionQueueManagerで管理されているモーション
	 * @param[in]   userTimeSeconds     デルタ時間の積算値[秒]
	 */
	updateFadeWeight(motionQueueEntry: CubismMotionQueueEntry, userTimeSeconds: number): number;
	/**
	 * フェードインの時間を設定する
	 * @param fadeInSeconds フェードインにかかる時間[秒]
	 */
	setFadeInTime(fadeInSeconds: number): void;
	/**
	 * フェードアウトの時間を設定する
	 * @param fadeOutSeconds フェードアウトにかかる時間[秒]
	 */
	setFadeOutTime(fadeOutSeconds: number): void;
	/**
	 * フェードアウトにかかる時間の取得
	 * @return フェードアウトにかかる時間[秒]
	 */
	getFadeOutTime(): number;
	/**
	 * フェードインにかかる時間の取得
	 * @return フェードインにかかる時間[秒]
	 */
	getFadeInTime(): number;
	/**
	 * モーション適用の重みの設定
	 * @param weight 重み（0.0 - 1.0）
	 */
	setWeight(weight: number): void;
	/**
	 * モーション適用の重みの取得
	 * @return 重み（0.0 - 1.0）
	 */
	getWeight(): number;
	/**
	 * モーションの長さの取得
	 * @return モーションの長さ[秒]
	 *
	 * @note ループの時は「-1」。
	 *       ループでない場合は、オーバーライドする。
	 *       正の値の時は取得される時間で終了する。
	 *       「-1」の時は外部から停止命令がない限り終わらない処理となる。
	 */
	getDuration(): number;
	/**
	 * モーションのループ1回分の長さの取得
	 * @return モーションのループ一回分の長さ[秒]
	 *
	 * @note ループしない場合は、getDuration()と同じ値を返す
	 *       ループ一回分の長さが定義できない場合(プログラム的に動き続けるサブクラスなど)の場合は「-1」を返す
	 */
	getLoopDuration(): number;
	/**
	 * モーション再生の開始時刻の設定
	 * @param offsetSeconds モーション再生の開始時刻[秒]
	 */
	setOffsetTime(offsetSeconds: number): void;
	/**
	 * ループ情報の設定
	 * @param loop ループ情報
	 */
	setLoop(loop: boolean): void;
	/**
	 * ループ情報の取得
	 * @return true ループする
	 * @return false ループしない
	 */
	getLoop(): boolean;
	/**
	 * ループ時のフェードイン情報の設定
	 * @param loopFadeIn  ループ時のフェードイン情報
	 */
	setLoopFadeIn(loopFadeIn: boolean): void;
	/**
	 * ループ時のフェードイン情報の取得
	 *
	 * @return  true    する
	 * @return  false   しない
	 */
	getLoopFadeIn(): boolean;
	/**
	 * モデルのパラメータ更新
	 *
	 * イベント発火のチェック。
	 * 入力する時間は呼ばれるモーションタイミングを０とした秒数で行う。
	 *
	 * @param beforeCheckTimeSeconds 前回のイベントチェック時間[秒]
	 * @param motionTimeSeconds 今回の再生時間[秒]
	 */
	getFiredEvent(beforeCheckTimeSeconds: number, motionTimeSeconds: number): csmVector<csmString>;
	/**
	 * モーションを更新して、モデルにパラメータ値を反映する
	 * @param model 対象のモデル
	 * @param userTimeSeconds デルタ時間の積算値[秒]
	 * @param weight モーションの重み
	 * @param motionQueueEntry CubismMotionQueueManagerで管理されているモーション
	 * @return true モデルへパラメータ値の反映あり
	 * @return false モデルへのパラメータ値の反映なし（モーションの変化なし）
	 */
	abstract doUpdateParameters(model: CubismModel, userTimeSeconds: number, weight: number, motionQueueEntry: CubismMotionQueueEntry): void;
	/**
	 * モーション再生開始コールバックの登録
	 *
	 * モーション再生開始コールバックを登録する。
	 * 以下の状態の際には呼び出されない:
	 *   1. 再生中のモーションが「ループ」として設定されているとき
	 *   2. コールバックが登録されていない時
	 *
	 * @param onBeganMotionHandler モーション再生開始コールバック関数
	 */
	setBeganMotionHandler: (onBeganMotionHandler: BeganMotionCallback) => BeganMotionCallback;
	/**
	 * モーション再生開始コールバックの取得
	 *
	 * モーション再生開始コールバックを取得する。
	 *
	 * @return 登録されているモーション再生開始コールバック関数
	 */
	getBeganMotionHandler: () => BeganMotionCallback;
	/**
	 * モーション再生終了コールバックの登録
	 *
	 * モーション再生終了コールバックを登録する。
	 * isFinishedフラグを設定するタイミングで呼び出される。
	 * 以下の状態の際には呼び出されない:
	 *   1. 再生中のモーションが「ループ」として設定されているとき
	 *   2. コールバックが登録されていない時
	 *
	 * @param onFinishedMotionHandler モーション再生終了コールバック関数
	 */
	setFinishedMotionHandler: (onFinishedMotionHandler: FinishedMotionCallback) => FinishedMotionCallback;
	/**
	 * モーション再生終了コールバックの取得
	 *
	 * モーション再生終了コールバックを取得する。
	 *
	 * @return 登録されているモーション再生終了コールバック関数
	 */
	getFinishedMotionHandler: () => FinishedMotionCallback;
	/**
	 * 透明度のカーブが存在するかどうかを確認する
	 *
	 * @returns true  -> キーが存在する
	 *          false -> キーが存在しない
	 */
	isExistModelOpacity(): boolean;
	/**
	 * 透明度のカーブのインデックスを返す
	 *
	 * @returns success:透明度のカーブのインデックス
	 */
	getModelOpacityIndex(): number;
	/**
	 * 透明度のIdを返す
	 *
	 * @param index モーションカーブのインデックス
	 * @returns success:透明度のId
	 */
	getModelOpacityId(index: number): CubismIdHandle;
	/**
	 * 指定時間の透明度の値を返す
	 *
	 * @returns success:モーションの現在時間におけるOpacityの値
	 *
	 * @note  更新後の値を取るにはUpdateParameters() の後に呼び出す。
	 */
	protected getModelOpacityValue(): number;
	/**
	 * 終了時刻の調整
	 * @param motionQueueEntry CubismMotionQueueManagerで管理されているモーション
	 */
	protected adjustEndTime(motionQueueEntry: CubismMotionQueueEntry): void;
	_fadeInSeconds: number;
	_fadeOutSeconds: number;
	_weight: number;
	_offsetSeconds: number;
	_isLoop: boolean;
	_isLoopFadeIn: boolean;
	_previousLoopState: boolean;
	_firedEventValues: csmVector<csmString>;
	_onBeganMotion?: BeganMotionCallback;
	_onFinishedMotion?: FinishedMotionCallback;
}
declare class ExpressionParameterValue {
	parameterId: CubismIdHandle;
	additiveValue: number;
	multiplyValue: number;
	overwriteValue: number;
}
declare class CubismExpressionMotionManager extends CubismMotionQueueManager {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * @deprecated
	 * ExpressionではPriorityを使用していないため、この関数は非推奨となりました。
	 *
	 * @brief 再生中のモーションの優先度の取得
	 *
	 * 再生中のモーションの優先度を取得する。
	 *
	 * @returns モーションの優先度
	 */
	getCurrentPriority(): number;
	/**
	 * @deprecated
	 * ExpressionではPriorityを使用していないため、この関数は非推奨となりました。
	 *
	 * @brief 予約中のモーションの優先度の取得
	 *
	 * 予約中のモーションの優先度を取得する。
	 *
	 * @return  モーションの優先度
	 */
	getReservePriority(): number;
	/**
	 * @brief 再生中のモーションのウェイトを取得する。
	 *
	 * @param[in]    index    表情のインデックス
	 * @returns               表情モーションのウェイト
	 */
	getFadeWeight(index: number): number;
	/**
	 * @brief モーションのウェイトの設定。
	 *
	 * @param[in]    index    表情のインデックス
	 * @param[in]    index    表情モーションのウェイト
	 */
	setFadeWeight(index: number, expressionFadeWeight: number): void;
	/**
	 * @deprecated
	 * ExpressionではPriorityを使用していないため、この関数は非推奨となりました。
	 *
	 * @brief 予約中のモーションの優先度の設定
	 *
	 * 予約中のモーションの優先度を設定する。
	 *
	 * @param[in]   priority     優先度
	 */
	setReservePriority(priority: number): void;
	/**
	 * @deprecated
	 * ExpressionではPriorityを使用していないため、この関数は非推奨となりました。
	 * CubismExpressionMotionManager.startMotion() を使用してください。
	 *
	 * @brief 優先度を設定してモーションの開始
	 *
	 * 優先度を設定してモーションを開始する。
	 *
	 * @param[in]   motion          モーション
	 * @param[in]   autoDelete      再生が終了したモーションのインスタンスを削除するならtrue
	 * @param[in]   priority        優先度
	 * @return                      開始したモーションの識別番号を返す。個別のモーションが終了したか否かを判定するIsFinished()の引数で使用する。開始できない時は「-1」
	 */
	startMotionPriority(motion: ACubismMotion, autoDelete: boolean, priority: number): CubismMotionQueueEntryHandle;
	/**
	 * @brief モーションの更新
	 *
	 * モーションを更新して、モデルにパラメータ値を反映する。
	 *
	 * @param[in]   model   対象のモデル
	 * @param[in]   deltaTimeSeconds    デルタ時間[秒]
	 * @retval  true    更新されている
	 * @retval  false   更新されていない
	 */
	updateMotion(model: CubismModel, deltaTimeSeconds: number): boolean;
	private _expressionParameterValues;
	private _fadeWeights;
	private _currentPriority;
	private _reservePriority;
	private _startExpressionTime;
}
declare enum CubismMotionCurveTarget {
	CubismMotionCurveTarget_Model = 0,// モデルに対して
	CubismMotionCurveTarget_Parameter = 1,// パラメータに対して
	CubismMotionCurveTarget_PartOpacity = 2
}
declare enum CubismMotionSegmentType {
	CubismMotionSegmentType_Linear = 0,// リニア
	CubismMotionSegmentType_Bezier = 1,// ベジェ曲線
	CubismMotionSegmentType_Stepped = 2,// ステップ
	CubismMotionSegmentType_InverseStepped = 3
}
declare class CubismMotionPoint {
	time: number;
	value: number;
}
/**
 * モーションカーブのセグメントの評価関数
 *
 * @param   points      モーションカーブの制御点リスト
 * @param   time        評価する時間[秒]
 */
export interface csmMotionSegmentEvaluationFunction {
	(points: CubismMotionPoint[], time: number): number;
}
declare class CubismMotionSegment {
	/**
	 * @brief コンストラクタ
	 *
	 * コンストラクタ。
	 */
	constructor();
	evaluate: csmMotionSegmentEvaluationFunction;
	basePointIndex: number;
	segmentType: number;
}
declare class CubismMotionCurve {
	constructor();
	type: CubismMotionCurveTarget;
	id: CubismIdHandle;
	segmentCount: number;
	baseSegmentIndex: number;
	fadeInTime: number;
	fadeOutTime: number;
}
declare class CubismMotionEvent {
	fireTime: number;
	value: csmString;
}
declare class CubismMotionData {
	constructor();
	duration: number;
	loop: boolean;
	curveCount: number;
	eventCount: number;
	fps: number;
	curves: csmVector<CubismMotionCurve>;
	segments: csmVector<CubismMotionSegment>;
	points: csmVector<CubismMotionPoint>;
	events: csmVector<CubismMotionEvent>;
}
declare enum MotionBehavior {
	MotionBehavior_V1 = 0,
	MotionBehavior_V2 = 1
}
declare class CubismMotion extends ACubismMotion {
	/**
	 * インスタンスを作成する
	 *
	 * @param buffer motion3.jsonが読み込まれているバッファ
	 * @param size バッファのサイズ
	 * @param onFinishedMotionHandler モーション再生終了時に呼び出されるコールバック関数
	 * @param onBeganMotionHandler モーション再生開始時に呼び出されるコールバック関数
	 * @param shouldCheckMotionConsistency motion3.json整合性チェックするかどうか
	 * @return 作成されたインスタンス
	 */
	static create(buffer: ArrayBuffer, size: number, onFinishedMotionHandler?: FinishedMotionCallback, onBeganMotionHandler?: BeganMotionCallback, shouldCheckMotionConsistency?: boolean): CubismMotion;
	/**
	 * モデルのパラメータの更新の実行
	 * @param model             対象のモデル
	 * @param userTimeSeconds   現在の時刻[秒]
	 * @param fadeWeight        モーションの重み
	 * @param motionQueueEntry  CubismMotionQueueManagerで管理されているモーション
	 */
	doUpdateParameters(model: CubismModel, userTimeSeconds: number, fadeWeight: number, motionQueueEntry: CubismMotionQueueEntry): void;
	/**
	 * ループ情報の設定
	 * @param loop ループ情報
	 */
	setIsLoop(loop: boolean): void;
	/**
	 * ループ情報の取得
	 * @return true ループする
	 * @return false ループしない
	 */
	isLoop(): boolean;
	/**
	 * ループ時のフェードイン情報の設定
	 * @param loopFadeIn  ループ時のフェードイン情報
	 */
	setIsLoopFadeIn(loopFadeIn: boolean): void;
	/**
	 * ループ時のフェードイン情報の取得
	 *
	 * @return  true    する
	 * @return  false   しない
	 */
	isLoopFadeIn(): boolean;
	/**
	 * Sets the version of the Motion Behavior.
	 *
	 * @param Specifies the version of the Motion Behavior.
	 */
	setMotionBehavior(motionBehavior: MotionBehavior): void;
	/**
	 * Gets the version of the Motion Behavior.
	 *
	 * @return Returns the version of the Motion Behavior.
	 */
	getMotionBehavior(): MotionBehavior;
	/**
	 * モーションの長さを取得する。
	 *
	 * @return  モーションの長さ[秒]
	 */
	getDuration(): number;
	/**
	 * モーションのループ時の長さを取得する。
	 *
	 * @return  モーションのループ時の長さ[秒]
	 */
	getLoopDuration(): number;
	/**
	 * パラメータに対するフェードインの時間を設定する。
	 *
	 * @param parameterId     パラメータID
	 * @param value           フェードインにかかる時間[秒]
	 */
	setParameterFadeInTime(parameterId: CubismIdHandle, value: number): void;
	/**
	 * パラメータに対するフェードアウトの時間の設定
	 * @param parameterId     パラメータID
	 * @param value           フェードアウトにかかる時間[秒]
	 */
	setParameterFadeOutTime(parameterId: CubismIdHandle, value: number): void;
	/**
	 * パラメータに対するフェードインの時間の取得
	 * @param    parameterId     パラメータID
	 * @return   フェードインにかかる時間[秒]
	 */
	getParameterFadeInTime(parameterId: CubismIdHandle): number;
	/**
	 * パラメータに対するフェードアウトの時間を取得
	 *
	 * @param   parameterId     パラメータID
	 * @return   フェードアウトにかかる時間[秒]
	 */
	getParameterFadeOutTime(parameterId: CubismIdHandle): number;
	/**
	 * 自動エフェクトがかかっているパラメータIDリストの設定
	 * @param eyeBlinkParameterIds    自動まばたきがかかっているパラメータIDのリスト
	 * @param lipSyncParameterIds     リップシンクがかかっているパラメータIDのリスト
	 */
	setEffectIds(eyeBlinkParameterIds: csmVector<CubismIdHandle>, lipSyncParameterIds: csmVector<CubismIdHandle>): void;
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 *
	 * @param motionQueueEntry
	 * @param userTimeSeconds
	 * @param time
	 */
	updateForNextLoop(motionQueueEntry: CubismMotionQueueEntry, userTimeSeconds: number, time: number): void;
	/**
	 * motion3.jsonをパースする。
	 *
	 * @param motionJson  motion3.jsonが読み込まれているバッファ
	 * @param size        バッファのサイズ
	 * @param shouldCheckMotionConsistency motion3.json整合性チェックするかどうか
	 */
	parse(motionJson: ArrayBuffer, size: number, shouldCheckMotionConsistency?: boolean): void;
	/**
	 * モデルのパラメータ更新
	 *
	 * イベント発火のチェック。
	 * 入力する時間は呼ばれるモーションタイミングを０とした秒数で行う。
	 *
	 * @param beforeCheckTimeSeconds   前回のイベントチェック時間[秒]
	 * @param motionTimeSeconds        今回の再生時間[秒]
	 */
	getFiredEvent(beforeCheckTimeSeconds: number, motionTimeSeconds: number): csmVector<csmString>;
	/**
	 * 透明度のカーブが存在するかどうかを確認する
	 *
	 * @returns true  -> キーが存在する
	 *          false -> キーが存在しない
	 */
	isExistModelOpacity(): boolean;
	/**
	 * 透明度のカーブのインデックスを返す
	 *
	 * @returns success:透明度のカーブのインデックス
	 */
	getModelOpacityIndex(): number;
	/**
	 * 透明度のIdを返す
	 *
	 * @param index モーションカーブのインデックス
	 * @returns success:透明度のカーブのインデックス
	 */
	getModelOpacityId(index: number): CubismIdHandle;
	/**
	 * 現在時間の透明度の値を返す
	 *
	 * @returns success:モーションの当該時間におけるOpacityの値
	 */
	getModelOpacityValue(): number;
	/**
	 * デバッグ用フラグを設定する
	 *
	 * @param debugMode デバッグモードの有効・無効
	 */
	setDebugMode(debugMode: boolean): void;
	_sourceFrameRate: number;
	_loopDurationSeconds: number;
	_motionBehavior: MotionBehavior;
	_lastWeight: number;
	_motionData: CubismMotionData;
	_eyeBlinkParameterIds: csmVector<CubismIdHandle>;
	_lipSyncParameterIds: csmVector<CubismIdHandle>;
	_modelCurveIdEyeBlink: CubismIdHandle;
	_modelCurveIdLipSync: CubismIdHandle;
	_modelCurveIdOpacity: CubismIdHandle;
	_modelOpacity: number;
	private _debugMode;
}
declare class CubismMotionManager extends CubismMotionQueueManager {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * 再生中のモーションの優先度の取得
	 * @return  モーションの優先度
	 */
	getCurrentPriority(): number;
	/**
	 * 予約中のモーションの優先度を取得する。
	 * @return  モーションの優先度
	 */
	getReservePriority(): number;
	/**
	 * 予約中のモーションの優先度を設定する。
	 * @param   val     優先度
	 */
	setReservePriority(val: number): void;
	/**
	 * 優先度を設定してモーションを開始する。
	 *
	 * @param motion          モーション
	 * @param autoDelete      再生が狩猟したモーションのインスタンスを削除するならtrue
	 * @param priority        優先度
	 * @return                開始したモーションの識別番号を返す。個別のモーションが終了したか否かを判定するIsFinished()の引数で使用する。開始できない時は「-1」
	 */
	startMotionPriority(motion: ACubismMotion, autoDelete: boolean, priority: number): CubismMotionQueueEntryHandle;
	/**
	 * モーションを更新して、モデルにパラメータ値を反映する。
	 *
	 * @param model   対象のモデル
	 * @param deltaTimeSeconds    デルタ時間[秒]
	 * @return  true    更新されている
	 * @return  false   更新されていない
	 */
	updateMotion(model: CubismModel, deltaTimeSeconds: number): boolean;
	/**
	 * モーションを予約する。
	 *
	 * @param   priority    優先度
	 * @return  true    予約できた
	 * @return  false   予約できなかった
	 */
	reserveMotion(priority: number): boolean;
	_currentPriority: number;
	_reservePriority: number;
}
declare enum CubismPhysicsTargetType {
	CubismPhysicsTargetType_Parameter = 0
}
declare enum CubismPhysicsSource {
	CubismPhysicsSource_X = 0,// X軸の位置から
	CubismPhysicsSource_Y = 1,// Y軸の位置から
	CubismPhysicsSource_Angle = 2
}
declare class PhysicsJsonEffectiveForces {
	constructor();
	gravity: CubismVector2;
	wind: CubismVector2;
}
declare class CubismPhysicsParameter {
	id: CubismIdHandle;
	targetType: CubismPhysicsTargetType;
}
declare class CubismPhysicsNormalization {
	minimum: number;
	maximum: number;
	defalut: number;
}
declare class CubismPhysicsParticle {
	constructor();
	initialPosition: CubismVector2;
	mobility: number;
	delay: number;
	acceleration: number;
	radius: number;
	position: CubismVector2;
	lastPosition: CubismVector2;
	lastGravity: CubismVector2;
	force: CubismVector2;
	velocity: CubismVector2;
}
declare class CubismPhysicsSubRig {
	constructor();
	inputCount: number;
	outputCount: number;
	particleCount: number;
	baseInputIndex: number;
	baseOutputIndex: number;
	baseParticleIndex: number;
	normalizationPosition: CubismPhysicsNormalization;
	normalizationAngle: CubismPhysicsNormalization;
}
/**
 * 正規化されたパラメータの取得関数の宣言
 * @param targetTranslation     // 演算結果の移動値
 * @param targetAngle           // 演算結果の角度
 * @param value                 // パラメータの値
 * @param parameterMinimunValue // パラメータの最小値
 * @param parameterMaximumValue // パラメータの最大値
 * @param parameterDefaultValue // パラメータのデフォルト値
 * @param normalizationPosition // 正規化された位置
 * @param normalizationAngle    // 正規化された角度
 * @param isInverted            // 値が反転されているか？
 * @param weight                // 重み
 */
export interface normalizedPhysicsParameterValueGetter {
	(targetTranslation: CubismVector2, targetAngle: {
		angle: number;
	}, value: number, parameterMinimunValue: number, parameterMaximumValue: number, parameterDefaultValue: number, normalizationPosition: CubismPhysicsNormalization, normalizationAngle: CubismPhysicsNormalization, isInverted: boolean, weight: number): void;
}
/**
 * 物理演算の値の取得関数の宣言
 * @param translation 移動値
 * @param particles 物理点のリスト
 * @param isInverted 値が反映されているか
 * @param parentGravity 重力
 * @return 値
 */
export interface physicsValueGetter {
	(translation: CubismVector2, particles: CubismPhysicsParticle[], particleIndex: number, isInverted: boolean, parentGravity: CubismVector2): number;
}
/**
 * 物理演算のスケールの取得関数の宣言
 * @param translationScale 移動値のスケール
 * @param angleScale    角度のスケール
 * @return スケール値
 */
export interface physicsScaleGetter {
	(translationScale: CubismVector2, angleScale: number): number;
}
declare class CubismPhysicsInput {
	constructor();
	source: CubismPhysicsParameter;
	sourceParameterIndex: number;
	weight: number;
	type: number;
	reflect: boolean;
	getNormalizedParameterValue: normalizedPhysicsParameterValueGetter;
}
declare class CubismPhysicsOutput {
	constructor();
	destination: CubismPhysicsParameter;
	destinationParameterIndex: number;
	vertexIndex: number;
	translationScale: CubismVector2;
	angleScale: number;
	weight: number;
	type: CubismPhysicsSource;
	reflect: boolean;
	valueBelowMinimum: number;
	valueExceededMaximum: number;
	getValue: physicsValueGetter;
	getScale: physicsScaleGetter;
}
declare class CubismPhysicsRig {
	constructor();
	subRigCount: number;
	settings: csmVector<CubismPhysicsSubRig>;
	inputs: csmVector<CubismPhysicsInput>;
	outputs: csmVector<CubismPhysicsOutput>;
	particles: csmVector<CubismPhysicsParticle>;
	gravity: CubismVector2;
	wind: CubismVector2;
	fps: number;
}
declare class CubismPhysics {
	/**
	 * インスタンスの作成
	 * @param buffer    physics3.jsonが読み込まれているバッファ
	 * @param size      バッファのサイズ
	 * @return 作成されたインスタンス
	 */
	static create(buffer: ArrayBuffer, size: number): CubismPhysics;
	/**
	 * インスタンスを破棄する
	 * @param physics 破棄するインスタンス
	 */
	static delete(physics: CubismPhysics): void;
	/**
	 * physics3.jsonをパースする。
	 * @param physicsJson physics3.jsonが読み込まれているバッファ
	 * @param size バッファのサイズ
	 */
	parse(physicsJson: ArrayBuffer, size: number): void;
	/**
	 * 現在のパラメータ値で物理演算が安定化する状態を演算する。
	 * @param model 物理演算の結果を適用するモデル
	 */
	stabilization(model: CubismModel): void;
	/**
	 * 物理演算の評価
	 *
	 * Pendulum interpolation weights
	 *
	 * 振り子の計算結果は保存され、パラメータへの出力は保存された前回の結果で補間されます。
	 * The result of the pendulum calculation is saved and
	 * the output to the parameters is interpolated with the saved previous result of the pendulum calculation.
	 *
	 * 図で示すと[1]と[2]で補間されます。
	 * The figure shows the interpolation between [1] and [2].
	 *
	 * 補間の重みは最新の振り子計算タイミングと次回のタイミングの間で見た現在時間で決定する。
	 * The weight of the interpolation are determined by the current time seen between
	 * the latest pendulum calculation timing and the next timing.
	 *
	 * 図で示すと[2]と[4]の間でみた(3)の位置の重みになる。
	 * Figure shows the weight of position (3) as seen between [2] and [4].
	 *
	 * 解釈として振り子計算のタイミングと重み計算のタイミングがズレる。
	 * As an interpretation, the pendulum calculation and weights are misaligned.
	 *
	 * physics3.jsonにFPS情報が存在しない場合は常に前の振り子状態で設定される。
	 * If there is no FPS information in physics3.json, it is always set in the previous pendulum state.
	 *
	 * この仕様は補間範囲を逸脱したことが原因の震えたような見た目を回避を目的にしている。
	 * The purpose of this specification is to avoid the quivering appearance caused by deviations from the interpolation range.
	 *
	 * ------------ time -------------->
	 *
	 *                 |+++++|------| <- weight
	 * ==[1]====#=====[2]---(3)----(4)
	 *          ^ output contents
	 *
	 * 1:_previousRigOutputs
	 * 2:_currentRigOutputs
	 * 3:_currentRemainTime (now rendering)
	 * 4:next particles timing
	 * @param model 物理演算の結果を適用するモデル
	 * @param deltaTimeSeconds デルタ時間[秒]
	 */
	evaluate(model: CubismModel, deltaTimeSeconds: number): void;
	/**
	 * 物理演算結果の適用
	 * 振り子演算の最新の結果と一つ前の結果から指定した重みで適用する。
	 * @param model 物理演算の結果を適用するモデル
	 * @param weight 最新結果の重み
	 */
	interpolate(model: CubismModel, weight: number): void;
	/**
	 * オプションの設定
	 * @param options オプション
	 */
	setOptions(options: Options): void;
	/**
	 * オプションの取得
	 * @return オプション
	 */
	getOption(): Options;
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * 初期化する
	 */
	initialize(): void;
	_physicsRig: CubismPhysicsRig;
	_options: Options;
	_currentRigOutputs: csmVector<PhysicsOutput>;
	_previousRigOutputs: csmVector<PhysicsOutput>;
	_currentRemainTime: number;
	_parameterCaches: Float32Array;
	_parameterInputCaches: Float32Array;
}
declare class Options {
	constructor();
	gravity: CubismVector2;
	wind: CubismVector2;
}
declare class PhysicsOutput {
	constructor();
	outputs: csmVector<number>;
}
declare class CubismClippingManager_WebGL extends CubismClippingManager<CubismClippingContext_WebGL> {
	/**
	 * テンポラリのレンダーテクスチャのアドレスを取得する
	 * FrameBufferObjectが存在しない場合、新しく生成する
	 *
	 * @return レンダーテクスチャの配列
	 */
	getMaskRenderTexture(): csmVector<WebGLFramebuffer>;
	/**
	 * WebGLレンダリングコンテキストを設定する
	 * @param gl WebGLレンダリングコンテキスト
	 */
	setGL(gl: WebGLRenderingContext): void;
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * クリッピングコンテキストを作成する。モデル描画時に実行する。
	 * @param model モデルのインスタンス
	 * @param renderer レンダラのインスタンス
	 */
	setupClippingContext(model: CubismModel, renderer: CubismRenderer_WebGL): void;
	/**
	 * カラーバッファを取得する
	 * @return カラーバッファ
	 */
	getColorBuffer(): csmVector<WebGLTexture>;
	/**
	 * マスクの合計数をカウント
	 * @returns
	 */
	getClippingMaskCount(): number;
	_currentMaskRenderTexture: WebGLFramebuffer;
	_maskRenderTextures: csmVector<WebGLFramebuffer>;
	_maskColorBuffers: csmVector<WebGLTexture>;
	_currentFrameNo: number;
	_maskTexture: CubismRenderTextureResource;
	gl: WebGLRenderingContext;
}
declare class CubismRenderTextureResource {
	/**
	 * 引数付きコンストラクタ
	 * @param frameNo レンダラーのフレーム番号
	 * @param texture テクスチャのアドレス
	 */
	constructor(frameNo: number, texture: csmVector<WebGLFramebuffer>);
	frameNo: number;
	textures: csmVector<WebGLFramebuffer>;
}
declare class CubismClippingContext_WebGL extends CubismClippingContext {
	/**
	 * 引数付きコンストラクタ
	 */
	constructor(manager: CubismClippingManager_WebGL, clippingDrawableIndices: Int32Array, clipCount: number);
	/**
	 * このマスクを管理するマネージャのインスタンスを取得する
	 * @return クリッピングマネージャのインスタンス
	 */
	getClippingManager(): CubismClippingManager_WebGL;
	setGl(gl: WebGLRenderingContext): void;
	private _owner;
}
declare class CubismRendererProfile_WebGL {
	private setGlEnable;
	private setGlEnableVertexAttribArray;
	save(): void;
	restore(): void;
	setGl(gl: WebGLRenderingContext): void;
	constructor();
	private _lastArrayBufferBinding;
	private _lastElementArrayBufferBinding;
	private _lastProgram;
	private _lastActiveTexture;
	private _lastTexture0Binding2D;
	private _lastTexture1Binding2D;
	private _lastVertexAttribArrayEnabled;
	private _lastScissorTest;
	private _lastBlend;
	private _lastStencilTest;
	private _lastDepthTest;
	private _lastCullFace;
	private _lastFrontFace;
	private _lastColorMask;
	private _lastBlending;
	private _lastFBO;
	private _lastViewport;
	gl: WebGLRenderingContext;
}
declare class CubismRenderer_WebGL extends CubismRenderer {
	/**
	 * レンダラの初期化処理を実行する
	 * 引数に渡したモデルからレンダラの初期化処理に必要な情報を取り出すことができる
	 *
	 * @param model モデルのインスタンス
	 * @param maskBufferCount バッファの生成数
	 */
	initialize(model: CubismModel, maskBufferCount?: number): void;
	/**
	 * WebGLテクスチャのバインド処理
	 * CubismRendererにテクスチャを設定し、CubismRenderer内でその画像を参照するためのIndex値を戻り値とする
	 * @param modelTextureNo セットするモデルテクスチャの番号
	 * @param glTextureNo WebGLテクスチャの番号
	 */
	bindTexture(modelTextureNo: number, glTexture: WebGLTexture): void;
	/**
	 * WebGLにバインドされたテクスチャのリストを取得する
	 * @return テクスチャのリスト
	 */
	getBindedTextures(): csmMap<number, WebGLTexture>;
	/**
	 * クリッピングマスクバッファのサイズを設定する
	 * マスク用のFrameBufferを破棄、再作成する為処理コストは高い
	 * @param size クリッピングマスクバッファのサイズ
	 */
	setClippingMaskBufferSize(size: number): void;
	/**
	 * クリッピングマスクバッファのサイズを取得する
	 * @return クリッピングマスクバッファのサイズ
	 */
	getClippingMaskBufferSize(): number;
	/**
	 * レンダーテクスチャの枚数を取得する
	 * @return レンダーテクスチャの枚数
	 */
	getRenderTextureCount(): number;
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * モデルを描画する実際の処理
	 */
	doDrawModel(): void;
	/**
	 * 描画オブジェクト（アートメッシュ）を描画する。
	 * @param model 描画対象のモデル
	 * @param index 描画対象のメッシュのインデックス
	 */
	drawMeshWebGL(model: Readonly<CubismModel>, index: number): void;
	protected saveProfile(): void;
	protected restoreProfile(): void;
	/**
	 * レンダラが保持する静的なリソースを解放する
	 * WebGLの静的なシェーダープログラムを解放する
	 */
	static doStaticRelease(): void;
	/**
	 * レンダーステートを設定する
	 * @param fbo アプリケーション側で指定しているフレームバッファ
	 * @param viewport ビューポート
	 */
	setRenderState(fbo: WebGLFramebuffer, viewport: number[]): void;
	/**
	 * 描画開始時の追加処理
	 * モデルを描画する前にクリッピングマスクに必要な処理を実装している
	 */
	preDraw(): void;
	/**
	 * マスクテクスチャに描画するクリッピングコンテキストをセットする
	 */
	setClippingContextBufferForMask(clip: CubismClippingContext_WebGL): void;
	/**
	 * マスクテクスチャに描画するクリッピングコンテキストを取得する
	 * @return マスクテクスチャに描画するクリッピングコンテキスト
	 */
	getClippingContextBufferForMask(): CubismClippingContext_WebGL;
	/**
	 * 画面上に描画するクリッピングコンテキストをセットする
	 */
	setClippingContextBufferForDraw(clip: CubismClippingContext_WebGL): void;
	/**
	 * 画面上に描画するクリッピングコンテキストを取得する
	 * @return 画面上に描画するクリッピングコンテキスト
	 */
	getClippingContextBufferForDraw(): CubismClippingContext_WebGL;
	/**
	 * マスク生成時かを判定する
	 * @returns 判定値
	 */
	isGeneratingMask(): boolean;
	/**
	 * glの設定
	 */
	startUp(gl: WebGLRenderingContext): void;
	_textures: csmMap<number, WebGLTexture>;
	_sortedDrawableIndexList: csmVector<number>;
	_clippingManager: CubismClippingManager_WebGL;
	_clippingContextBufferForMask: CubismClippingContext_WebGL;
	_clippingContextBufferForDraw: CubismClippingContext_WebGL;
	_rendererProfile: CubismRendererProfile_WebGL;
	firstDraw: boolean;
	_bufferData: {
		vertex: WebGLBuffer;
		uv: WebGLBuffer;
		index: WebGLBuffer;
	};
	_extension: any;
	gl: WebGLRenderingContext;
}
declare class CubismUserModel {
	/**
	 * 初期化状態の取得
	 *
	 * 初期化されている状態か？
	 *
	 * @return true     初期化されている
	 * @return false    初期化されていない
	 */
	isInitialized(): boolean;
	/**
	 * 初期化状態の設定
	 *
	 * 初期化状態を設定する。
	 *
	 * @param v 初期化状態
	 */
	setInitialized(v: boolean): void;
	/**
	 * 更新状態の取得
	 *
	 * 更新されている状態か？
	 *
	 * @return true     更新されている
	 * @return false    更新されていない
	 */
	isUpdating(): boolean;
	/**
	 * 更新状態の設定
	 *
	 * 更新状態を設定する
	 *
	 * @param v 更新状態
	 */
	setUpdating(v: boolean): void;
	/**
	 * マウスドラッグ情報の設定
	 * @param ドラッグしているカーソルのX位置
	 * @param ドラッグしているカーソルのY位置
	 */
	setDragging(x: number, y: number): void;
	/**
	 * 加速度の情報を設定する
	 * @param x X軸方向の加速度
	 * @param y Y軸方向の加速度
	 * @param z Z軸方向の加速度
	 */
	setAcceleration(x: number, y: number, z: number): void;
	/**
	 * モデル行列を取得する
	 * @return モデル行列
	 */
	getModelMatrix(): CubismModelMatrix;
	/**
	 * 不透明度の設定
	 * @param a 不透明度
	 */
	setOpacity(a: number): void;
	/**
	 * 不透明度の取得
	 * @return 不透明度
	 */
	getOpacity(): number;
	/**
	 * モデルデータを読み込む
	 *
	 * @param buffer    moc3ファイルが読み込まれているバッファ
	 */
	loadModel(buffer: ArrayBuffer, shouldCheckMocConsistency?: boolean): void;
	/**
	 * モーションデータを読み込む
	 * @param buffer motion3.jsonファイルが読み込まれているバッファ
	 * @param size バッファのサイズ
	 * @param name モーションの名前
	 * @param onFinishedMotionHandler モーション再生終了時に呼び出されるコールバック関数
	 * @param onBeganMotionHandler モーション再生開始時に呼び出されるコールバック関数
	 * @param modelSetting モデル設定
	 * @param group モーショングループ名
	 * @param index モーションインデックス
	 * @param shouldCheckMotionConsistency motion3.json整合性チェックするかどうか
	 * @return モーションクラス
	 */
	loadMotion(buffer: ArrayBuffer, size: number, name: string, onFinishedMotionHandler?: FinishedMotionCallback, onBeganMotionHandler?: BeganMotionCallback, modelSetting?: ICubismModelSetting, group?: string, index?: number, shouldCheckMotionConsistency?: boolean): CubismMotion;
	/**
	 * 表情データの読み込み
	 * @param buffer expファイルが読み込まれているバッファ
	 * @param size バッファのサイズ
	 * @param name 表情の名前
	 */
	loadExpression(buffer: ArrayBuffer, size: number, name: string): ACubismMotion;
	/**
	 * ポーズデータの読み込み
	 * @param buffer pose3.jsonが読み込まれているバッファ
	 * @param size バッファのサイズ
	 */
	loadPose(buffer: ArrayBuffer, size: number): void;
	/**
	 * モデルに付属するユーザーデータを読み込む
	 * @param buffer userdata3.jsonが読み込まれているバッファ
	 * @param size バッファのサイズ
	 */
	loadUserData(buffer: ArrayBuffer, size: number): void;
	/**
	 * 物理演算データの読み込み
	 * @param buffer  physics3.jsonが読み込まれているバッファ
	 * @param size    バッファのサイズ
	 */
	loadPhysics(buffer: ArrayBuffer, size: number): void;
	/**
	 * 当たり判定の取得
	 * @param drawableId 検証したいDrawableのID
	 * @param pointX X位置
	 * @param pointY Y位置
	 * @return true ヒットしている
	 * @return false ヒットしていない
	 */
	isHit(drawableId: CubismIdHandle, pointX: number, pointY: number): boolean;
	/**
	 * モデルの取得
	 * @return モデル
	 */
	getModel(): CubismModel;
	/**
	 * レンダラの取得
	 * @return レンダラ
	 */
	getRenderer(): CubismRenderer_WebGL;
	/**
	 * レンダラを作成して初期化を実行する
	 * @param maskBufferCount バッファの生成数
	 */
	createRenderer(maskBufferCount?: number): void;
	/**
	 * レンダラの解放
	 */
	deleteRenderer(): void;
	/**
	 * イベント発火時の標準処理
	 *
	 * Eventが再生処理時にあった場合の処理をする。
	 * 継承で上書きすることを想定している。
	 * 上書きしない場合はログ出力をする。
	 *
	 * @param eventValue 発火したイベントの文字列データ
	 */
	motionEventFired(eventValue: csmString): void;
	/**
	 * イベント用のコールバック
	 *
	 * CubismMotionQueueManagerにイベント用に登録するためのCallback。
	 * CubismUserModelの継承先のEventFiredを呼ぶ。
	 *
	 * @param caller 発火したイベントを管理していたモーションマネージャー、比較用
	 * @param eventValue 発火したイベントの文字列データ
	 * @param customData CubismUserModelを継承したインスタンスを想定
	 */
	static cubismDefaultMotionEventCallback(caller: CubismMotionQueueManager, eventValue: csmString, customData: CubismUserModel): void;
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタに相当する処理
	 */
	release(): void;
	protected _moc: CubismMoc;
	protected _model: CubismModel;
	protected _motionManager: CubismMotionManager;
	protected _expressionManager: CubismExpressionMotionManager;
	protected _eyeBlink: CubismEyeBlink;
	protected _breath: CubismBreath;
	protected _modelMatrix: CubismModelMatrix;
	protected _pose: CubismPose;
	protected _dragManager: CubismTargetPoint;
	protected _physics: CubismPhysics;
	protected _modelUserData: CubismModelUserData;
	protected _initialized: boolean;
	protected _updating: boolean;
	protected _opacity: number;
	protected _lipsync: boolean;
	protected _lastLipSyncValue: number;
	protected _dragX: number;
	protected _dragY: number;
	protected _accelerationX: number;
	protected _accelerationY: number;
	protected _accelerationZ: number;
	protected _mocConsistency: boolean;
	protected _motionConsistency: boolean;
	protected _debugMode: boolean;
	private _renderer;
}
declare class CubismExpressionMotion extends ACubismMotion {
	static readonly DefaultAdditiveValue = 0;
	static readonly DefaultMultiplyValue = 1;
	/**
	 * インスタンスを作成する。
	 * @param buffer expファイルが読み込まれているバッファ
	 * @param size バッファのサイズ
	 * @return 作成されたインスタンス
	 */
	static create(buffer: ArrayBuffer, size: number): CubismExpressionMotion;
	/**
	 * モデルのパラメータの更新の実行
	 * @param model 対象のモデル
	 * @param userTimeSeconds デルタ時間の積算値[秒]
	 * @param weight モーションの重み
	 * @param motionQueueEntry CubismMotionQueueManagerで管理されているモーション
	 */
	doUpdateParameters(model: CubismModel, userTimeSeconds: number, weight: number, motionQueueEntry: CubismMotionQueueEntry): void;
	/**
	 * @brief 表情によるモデルのパラメータの計算
	 *
	 * モデルの表情に関するパラメータを計算する。
	 *
	 * @param[in]   model                        対象のモデル
	 * @param[in]   userTimeSeconds              デルタ時間の積算値[秒]
	 * @param[in]   motionQueueEntry             CubismMotionQueueManagerで管理されているモーション
	 * @param[in]   expressionParameterValues    モデルに適用する各パラメータの値
	 * @param[in]   expressionIndex              表情のインデックス
	 * @param[in]   fadeWeight                   表情のウェイト
	 */
	calculateExpressionParameters(model: CubismModel, userTimeSeconds: number, motionQueueEntry: CubismMotionQueueEntry, expressionParameterValues: csmVector<ExpressionParameterValue>, expressionIndex: number, fadeWeight: number): void;
	/**
	 * @brief 表情が参照しているパラメータを取得
	 *
	 * 表情が参照しているパラメータを取得する
	 *
	 * @return 表情パラメータ
	 */
	getExpressionParameters(): csmVector<ExpressionParameter>;
	/**
	 * @brief 表情のフェードの値を取得
	 *
	 * 現在の表情のフェードのウェイト値を取得する
	 *
	 * @returns 表情のフェードのウェイト値
	 *
	 * @deprecated CubismExpressionMotion.fadeWeightが削除予定のため非推奨。
	 * CubismExpressionMotionManager.getFadeWeight(index: number): number を使用してください。
	 * @see CubismExpressionMotionManager#getFadeWeight(index: number)
	 */
	getFadeWeight(): number;
	protected parse(buffer: ArrayBuffer, size: number): void;
	/**
	 * @brief ブレンド計算
	 *
	 * 入力された値でブレンド計算をする。
	 *
	 * @param source 現在の値
	 * @param destination 適用する値
	 * @param weight ウェイト
	 * @returns 計算結果
	 */
	calculateValue(source: number, destination: number, fadeWeight: number): number;
	/**
	 * コンストラクタ
	 */
	protected constructor();
	private _parameters;
	/**
	 * 表情の現在のウェイト
	 *
	 * @deprecated 不具合を引き起こす要因となるため非推奨。
	 */
	private _fadeWeight;
}
declare enum ExpressionBlendType {
	Additive = 0,// 加算
	Multiply = 1,// 乗算
	Overwrite = 2
}
declare class ExpressionParameter {
	parameterId: CubismIdHandle;
	blendType: ExpressionBlendType;
	value: number;
}
declare class CubismMotionJson {
	/**
	 * コンストラクタ
	 * @param buffer motion3.jsonが読み込まれているバッファ
	 * @param size バッファのサイズ
	 */
	constructor(buffer: ArrayBuffer, size: number);
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * モーションの長さを取得する
	 * @return モーションの長さ[秒]
	 */
	getMotionDuration(): number;
	/**
	 * モーションのループ情報の取得
	 * @return true ループする
	 * @return false ループしない
	 */
	isMotionLoop(): boolean;
	/**
	 *  motion3.jsonファイルの整合性チェック
	 *
	 * @return 正常なファイルの場合はtrueを返す。
	 */
	hasConsistency(): boolean;
	getEvaluationOptionFlag(flagType: EvaluationOptionFlag): boolean;
	/**
	 * モーションカーブの個数の取得
	 * @return モーションカーブの個数
	 */
	getMotionCurveCount(): number;
	/**
	 * モーションのフレームレートの取得
	 * @return フレームレート[FPS]
	 */
	getMotionFps(): number;
	/**
	 * モーションのセグメントの総合計の取得
	 * @return モーションのセグメントの取得
	 */
	getMotionTotalSegmentCount(): number;
	/**
	 * モーションのカーブの制御店の総合計の取得
	 * @return モーションのカーブの制御点の総合計
	 */
	getMotionTotalPointCount(): number;
	/**
	 * モーションのフェードイン時間の存在
	 * @return true 存在する
	 * @return false 存在しない
	 */
	isExistMotionFadeInTime(): boolean;
	/**
	 * モーションのフェードアウト時間の存在
	 * @return true 存在する
	 * @return false 存在しない
	 */
	isExistMotionFadeOutTime(): boolean;
	/**
	 * モーションのフェードイン時間の取得
	 * @return フェードイン時間[秒]
	 */
	getMotionFadeInTime(): number;
	/**
	 * モーションのフェードアウト時間の取得
	 * @return フェードアウト時間[秒]
	 */
	getMotionFadeOutTime(): number;
	/**
	 * モーションのカーブの種類の取得
	 * @param curveIndex カーブのインデックス
	 * @return カーブの種類
	 */
	getMotionCurveTarget(curveIndex: number): string;
	/**
	 * モーションのカーブのIDの取得
	 * @param curveIndex カーブのインデックス
	 * @return カーブのID
	 */
	getMotionCurveId(curveIndex: number): CubismIdHandle;
	/**
	 * モーションのカーブのフェードイン時間の存在
	 * @param curveIndex カーブのインデックス
	 * @return true 存在する
	 * @return false 存在しない
	 */
	isExistMotionCurveFadeInTime(curveIndex: number): boolean;
	/**
	 * モーションのカーブのフェードアウト時間の存在
	 * @param curveIndex カーブのインデックス
	 * @return true 存在する
	 * @return false 存在しない
	 */
	isExistMotionCurveFadeOutTime(curveIndex: number): boolean;
	/**
	 * モーションのカーブのフェードイン時間の取得
	 * @param curveIndex カーブのインデックス
	 * @return フェードイン時間[秒]
	 */
	getMotionCurveFadeInTime(curveIndex: number): number;
	/**
	 * モーションのカーブのフェードアウト時間の取得
	 * @param curveIndex カーブのインデックス
	 * @return フェードアウト時間[秒]
	 */
	getMotionCurveFadeOutTime(curveIndex: number): number;
	/**
	 * モーションのカーブのセグメントの個数を取得する
	 * @param curveIndex カーブのインデックス
	 * @return モーションのカーブのセグメントの個数
	 */
	getMotionCurveSegmentCount(curveIndex: number): number;
	/**
	 * モーションのカーブのセグメントの値の取得
	 * @param curveIndex カーブのインデックス
	 * @param segmentIndex セグメントのインデックス
	 * @return セグメントの値
	 */
	getMotionCurveSegment(curveIndex: number, segmentIndex: number): number;
	/**
	 * イベントの個数の取得
	 * @return イベントの個数
	 */
	getEventCount(): number;
	/**
	 *  イベントの総文字数の取得
	 * @return イベントの総文字数
	 */
	getTotalEventValueSize(): number;
	/**
	 * イベントの時間の取得
	 * @param userDataIndex イベントのインデックス
	 * @return イベントの時間[秒]
	 */
	getEventTime(userDataIndex: number): number;
	/**
	 * イベントの取得
	 * @param userDataIndex イベントのインデックス
	 * @return イベントの文字列
	 */
	getEventValue(userDataIndex: number): csmString;
	_json: CubismJson;
}
declare enum EvaluationOptionFlag {
	EvaluationOptionFlag_AreBeziersRistricted = 0
}
declare class CubismPhysicsJson {
	/**
	 * コンストラクタ
	 * @param buffer physics3.jsonが読み込まれているバッファ
	 * @param size バッファのサイズ
	 */
	constructor(buffer: ArrayBuffer, size: number);
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * 重力の取得
	 * @return 重力
	 */
	getGravity(): CubismVector2;
	/**
	 * 風の取得
	 * @return 風
	 */
	getWind(): CubismVector2;
	/**
	 * 物理演算設定FPSの取得
	 * @return 物理演算設定FPS
	 */
	getFps(): number;
	/**
	 * 物理店の管理の個数の取得
	 * @return 物理店の管理の個数
	 */
	getSubRigCount(): number;
	/**
	 * 入力の総合計の取得
	 * @return 入力の総合計
	 */
	getTotalInputCount(): number;
	/**
	 * 出力の総合計の取得
	 * @return 出力の総合計
	 */
	getTotalOutputCount(): number;
	/**
	 * 物理点の個数の取得
	 * @return 物理点の個数
	 */
	getVertexCount(): number;
	/**
	 * 正規化された位置の最小値の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @return 正規化された位置の最小値
	 */
	getNormalizationPositionMinimumValue(physicsSettingIndex: number): number;
	/**
	 * 正規化された位置の最大値の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @return 正規化された位置の最大値
	 */
	getNormalizationPositionMaximumValue(physicsSettingIndex: number): number;
	/**
	 * 正規化された位置のデフォルト値の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @return 正規化された位置のデフォルト値
	 */
	getNormalizationPositionDefaultValue(physicsSettingIndex: number): number;
	/**
	 * 正規化された角度の最小値の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @return 正規化された角度の最小値
	 */
	getNormalizationAngleMinimumValue(physicsSettingIndex: number): number;
	/**
	 * 正規化された角度の最大値の取得
	 * @param physicsSettingIndex
	 * @return 正規化された角度の最大値
	 */
	getNormalizationAngleMaximumValue(physicsSettingIndex: number): number;
	/**
	 * 正規化された角度のデフォルト値の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @return 正規化された角度のデフォルト値
	 */
	getNormalizationAngleDefaultValue(physicsSettingIndex: number): number;
	/**
	 * 入力の個数の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @return 入力の個数
	 */
	getInputCount(physicsSettingIndex: number): number;
	/**
	 * 入力の重みの取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param inputIndex 入力のインデックス
	 * @return 入力の重み
	 */
	getInputWeight(physicsSettingIndex: number, inputIndex: number): number;
	/**
	 * 入力の反転の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param inputIndex 入力のインデックス
	 * @return 入力の反転
	 */
	getInputReflect(physicsSettingIndex: number, inputIndex: number): boolean;
	/**
	 * 入力の種類の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param inputIndex 入力のインデックス
	 * @return 入力の種類
	 */
	getInputType(physicsSettingIndex: number, inputIndex: number): string;
	/**
	 * 入力元のIDの取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param inputIndex 入力のインデックス
	 * @return 入力元のID
	 */
	getInputSourceId(physicsSettingIndex: number, inputIndex: number): CubismIdHandle;
	/**
	 * 出力の個数の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @return 出力の個数
	 */
	getOutputCount(physicsSettingIndex: number): number;
	/**
	 * 出力の物理点のインデックスの取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param outputIndex 出力のインデックス
	 * @return 出力の物理点のインデックス
	 */
	getOutputVertexIndex(physicsSettingIndex: number, outputIndex: number): number;
	/**
	 * 出力の角度のスケールを取得する
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param outputIndex 出力のインデックス
	 * @return 出力の角度のスケール
	 */
	getOutputAngleScale(physicsSettingIndex: number, outputIndex: number): number;
	/**
	 * 出力の重みの取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param outputIndex 出力のインデックス
	 * @return 出力の重み
	 */
	getOutputWeight(physicsSettingIndex: number, outputIndex: number): number;
	/**
	 * 出力先のIDの取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param outputIndex 出力のインデックス
	 * @return 出力先のID
	 */
	getOutputDestinationId(physicsSettingIndex: number, outputIndex: number): CubismIdHandle;
	/**
	 * 出力の種類の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param outputIndex 出力のインデックス
	 * @return 出力の種類
	 */
	getOutputType(physicsSettingIndex: number, outputIndex: number): string;
	/**
	 * 出力の反転の取得
	 * @param physicsSettingIndex 物理演算のインデックス
	 * @param outputIndex 出力のインデックス
	 * @return 出力の反転
	 */
	getOutputReflect(physicsSettingIndex: number, outputIndex: number): boolean;
	/**
	 * 物理点の個数の取得
	 * @param physicsSettingIndex 物理演算男設定のインデックス
	 * @return 物理点の個数
	 */
	getParticleCount(physicsSettingIndex: number): number;
	/**
	 * 物理点の動きやすさの取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param vertexIndex 物理点のインデックス
	 * @return 物理点の動きやすさ
	 */
	getParticleMobility(physicsSettingIndex: number, vertexIndex: number): number;
	/**
	 * 物理点の遅れの取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param vertexIndex 物理点のインデックス
	 * @return 物理点の遅れ
	 */
	getParticleDelay(physicsSettingIndex: number, vertexIndex: number): number;
	/**
	 * 物理点の加速度の取得
	 * @param physicsSettingIndex 物理演算の設定
	 * @param vertexIndex 物理点のインデックス
	 * @return 物理点の加速度
	 */
	getParticleAcceleration(physicsSettingIndex: number, vertexIndex: number): number;
	/**
	 * 物理点の距離の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param vertexIndex 物理点のインデックス
	 * @return 物理点の距離
	 */
	getParticleRadius(physicsSettingIndex: number, vertexIndex: number): number;
	/**
	 * 物理点の位置の取得
	 * @param physicsSettingIndex 物理演算の設定のインデックス
	 * @param vertexInde 物理点のインデックス
	 * @return 物理点の位置
	 */
	getParticlePosition(physicsSettingIndex: number, vertexIndex: number): CubismVector2;
	_json: CubismJson;
}
declare class CubismShader_WebGL {
	/**
	 * コンストラクタ
	 */
	constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * 描画用のシェーダプログラムの一連のセットアップを実行する
	 * @param renderer レンダラー
	 * @param model 描画対象のモデル
	 * @param index 描画対象のメッシュのインデックス
	 */
	setupShaderProgramForDraw(renderer: CubismRenderer_WebGL, model: Readonly<CubismModel>, index: number): void;
	/**
	 * マスク用のシェーダプログラムの一連のセットアップを実行する
	 * @param renderer レンダラー
	 * @param model 描画対象のモデル
	 * @param index 描画対象のメッシュのインデックス
	 */
	setupShaderProgramForMask(renderer: CubismRenderer_WebGL, model: Readonly<CubismModel>, index: number): void;
	/**
	 * シェーダープログラムを解放する
	 */
	releaseShaderProgram(): void;
	/**
	 * シェーダープログラムを初期化する
	 * @param vertShaderSrc 頂点シェーダのソース
	 * @param fragShaderSrc フラグメントシェーダのソース
	 */
	generateShaders(): void;
	/**
	 * シェーダプログラムをロードしてアドレスを返す
	 * @param vertexShaderSource    頂点シェーダのソース
	 * @param fragmentShaderSource  フラグメントシェーダのソース
	 * @return シェーダプログラムのアドレス
	 */
	loadShaderProgram(vertexShaderSource: string, fragmentShaderSource: string): WebGLProgram;
	/**
	 * シェーダープログラムをコンパイルする
	 * @param shaderType シェーダタイプ(Vertex/Fragment)
	 * @param shaderSource シェーダソースコード
	 *
	 * @return コンパイルされたシェーダープログラム
	 */
	compileShaderSource(shaderType: GLenum, shaderSource: string): WebGLProgram;
	setGl(gl: WebGLRenderingContext): void;
	_shaderSets: csmVector<CubismShaderSet>;
	gl: WebGLRenderingContext;
}
declare class CubismShaderManager_WebGL {
	/**
	 * インスタンスを取得する（シングルトン）
	 * @return インスタンス
	 */
	static getInstance(): CubismShaderManager_WebGL;
	/**
	 * インスタンスを開放する（シングルトン）
	 */
	static deleteInstance(): void;
	/**
	 * Privateなコンストラクタ
	 */
	private constructor();
	/**
	 * デストラクタ相当の処理
	 */
	release(): void;
	/**
	 * GLContextをキーにShaderを取得する
	 * @param gl
	 * @returns
	 */
	getShader(gl: WebGLRenderingContext): CubismShader_WebGL;
	/**
	 * GLContextを登録する
	 * @param gl
	 */
	setGlContext(gl: WebGLRenderingContext): void;
	/**
	 * GLContextごとのShaderを保持する変数
	 */
	private _shaderMap;
}
declare class CubismShaderSet {
	shaderProgram: WebGLProgram;
	attributePositionLocation: GLuint;
	attributeTexCoordLocation: GLuint;
	uniformMatrixLocation: WebGLUniformLocation;
	uniformClipMatrixLocation: WebGLUniformLocation;
	samplerTexture0Location: WebGLUniformLocation;
	samplerTexture1Location: WebGLUniformLocation;
	uniformBaseColorLocation: WebGLUniformLocation;
	uniformChannelFlagLocation: WebGLUniformLocation;
	uniformMultiplyColorLocation: WebGLUniformLocation;
	uniformScreenColorLocation: WebGLUniformLocation;
}
declare enum ShaderNames {
	ShaderNames_SetupMask = 0,
	ShaderNames_NormalPremultipliedAlpha = 1,
	ShaderNames_NormalMaskedPremultipliedAlpha = 2,
	ShaderNames_NomralMaskedInvertedPremultipliedAlpha = 3,
	ShaderNames_AddPremultipliedAlpha = 4,
	ShaderNames_AddMaskedPremultipliedAlpha = 5,
	ShaderNames_AddMaskedPremultipliedAlphaInverted = 6,
	ShaderNames_MultPremultipliedAlpha = 7,
	ShaderNames_MultMaskedPremultipliedAlpha = 8,
	ShaderNames_MultMaskedPremultipliedAlphaInverted = 9
}
declare const vertexShaderSrcSetupMask: string;
declare const fragmentShaderSrcsetupMask: string;
declare const vertexShaderSrc: string;
declare const vertexShaderSrcMasked: string;
declare const fragmentShaderSrcPremultipliedAlpha: string;
declare const fragmentShaderSrcMaskPremultipliedAlpha: string;
declare const fragmentShaderSrcMaskInvertedPremultipliedAlpha: string;
declare const CubismLogPrint: (level: LogLevel, fmt: string, args: any[]) => void;
declare const CubismLogPrintIn: (level: LogLevel, fmt: string, args: any[]) => void;
declare const CSM_ASSERT: (expr: any) => void;
declare class CubismDebug {
	/**
	 * ログを出力する。第一引数にログレベルを設定する。
	 * CubismFramework.initialize()時にオプションで設定されたログ出力レベルを下回る場合はログに出さない。
	 *
	 * @param logLevel ログレベルの設定
	 * @param format 書式付き文字列
	 * @param args 可変長引数
	 */
	static print(logLevel: LogLevel, format: string, args?: any[]): void;
	/**
	 * データから指定した長さだけダンプ出力する。
	 * CubismFramework.initialize()時にオプションで設定されたログ出力レベルを下回る場合はログに出さない。
	 *
	 * @param logLevel ログレベルの設定
	 * @param data ダンプするデータ
	 * @param length ダンプする長さ
	 */
	static dumpBytes(logLevel: LogLevel, data: Uint8Array, length: number): void;
	/**
	 * private コンストラクタ
	 */
	private constructor();
}
declare class CubismJsonExtension {
	static parseJsonObject(obj: Value, map: JsonMap): JsonMap;
	protected static parseJsonArray(obj: Value): JsonArray;
}
declare class CubismString {
	/**
	 * 標準出力の書式を適用した文字列を取得する。
	 * @param format    標準出力の書式指定文字列
	 * @param ...args   書式指定文字列に渡す文字列
	 * @return 書式を適用した文字列
	 */
	static getFormatedString(format: string, ...args: any[]): string;
	/**
	 * textがstartWordで始まっているかどうかを返す
	 * @param test 検査対象の文字列
	 * @param startWord 比較対象の文字列
	 * @return true textがstartWordで始まっている
	 * @return false textがstartWordで始まっていない
	 */
	static isStartWith(text: string, startWord: string): boolean;
	/**
	 * position位置の文字から数字を解析する。
	 *
	 * @param string 文字列
	 * @param length 文字列の長さ
	 * @param position 解析したい文字の位置
	 * @param outEndPos 一文字も読み込まなかった場合はエラー値(-1)が入る
	 * @return 解析結果の数値
	 */
	static stringToFloat(string: string, length: number, position: number, outEndPos: number[]): number;
	/**
	 * コンストラクタ呼び出し不可な静的クラスにする。
	 */
	private constructor();
}
declare namespace effect {
	export import CubismBreath = CubismBreath;
	export import BreathParameterData = BreathParameterData;
	export import CubismEyeBlink = CubismEyeBlink;
	export import EyeState = EyeState;
	export import CubismPose = CubismPose;
	export import PartData = PartData;
}
declare namespace id {
	export import CubismId = CubismId;
	export import CubismIdManager = CubismIdManager;
}
declare namespace math {
	export import CubismMath = CubismMath;
	export import CubismMatrix44 = CubismMatrix44;
	export import CubismModelMatrix = CubismModelMatrix;
	export import CubismTargetPoint = CubismTargetPoint;
	export import CubismVector2 = CubismVector2;
	export import CubismViewMatrix = CubismViewMatrix;
}
declare namespace model {
	export import CubismMoc = CubismMoc;
	export import ParameterRepeatData = ParameterRepeatData;
	export import DrawableColorData = DrawableColorData;
	export import PartColorData = PartColorData;
	export import DrawableCullingData = DrawableCullingData;
	export import CubismModel = CubismModel;
	export import CubismModelUserDataNode = CubismModelUserDataNode;
	export import CubismModelUserData = CubismModelUserData;
	export import CubismModelUserDataJson = CubismModelUserDataJson;
	export import CubismUserModel = CubismUserModel;
}
declare namespace motion {
	export import ACubismMotion = ACubismMotion;
	export import BeganMotionCallback = BeganMotionCallback;
	export import FinishedMotionCallback = FinishedMotionCallback;
	export import CubismExpressionMotion = CubismExpressionMotion;
	export import ExpressionParameter = ExpressionParameter;
	export import ExpressionBlendType = ExpressionBlendType;
	export import ExpressionParameterValue = ExpressionParameterValue;
	export import CubismExpressionMotionManager = CubismExpressionMotionManager;
	export import CubismMotion = CubismMotion;
	export import MotionBehavior = MotionBehavior;
	export import CubismMotionPoint = CubismMotionPoint;
	export import CubismMotionSegment = CubismMotionSegment;
	export import CubismMotionCurve = CubismMotionCurve;
	export import CubismMotionEvent = CubismMotionEvent;
	export import CubismMotionData = CubismMotionData;
	export import CubismMotionCurveTarget = CubismMotionCurveTarget;
	export import CubismMotionSegmentType = CubismMotionSegmentType;
	export import csmMotionSegmentEvaluationFunction = csmMotionSegmentEvaluationFunction;
	export import CubismMotionJson = CubismMotionJson;
	export import EvaluationOptionFlag = EvaluationOptionFlag;
	export import CubismMotionManager = CubismMotionManager;
	export import CubismMotionQueueEntry = CubismMotionQueueEntry;
	export import CubismMotionQueueManager = CubismMotionQueueManager;
	export import CubismMotionEventFunction = CubismMotionEventFunction;
	export import InvalidMotionQueueEntryHandleValue = InvalidMotionQueueEntryHandleValue;
}
declare namespace physics {
	export import CubismPhysics = CubismPhysics;
	export import Options = Options;
	export import PhysicsOutput = PhysicsOutput;
	export import PhysicsJsonEffectiveForces = PhysicsJsonEffectiveForces;
	export import CubismPhysicsParameter = CubismPhysicsParameter;
	export import CubismPhysicsNormalization = CubismPhysicsNormalization;
	export import CubismPhysicsParticle = CubismPhysicsParticle;
	export import CubismPhysicsSubRig = CubismPhysicsSubRig;
	export import CubismPhysicsInput = CubismPhysicsInput;
	export import CubismPhysicsOutput = CubismPhysicsOutput;
	export import CubismPhysicsRig = CubismPhysicsRig;
	export import CubismPhysicsTargetType = CubismPhysicsTargetType;
	export import CubismPhysicsSource = CubismPhysicsSource;
	export import normalizedPhysicsParameterValueGetter = normalizedPhysicsParameterValueGetter;
	export import physicsValueGetter = physicsValueGetter;
	export import physicsScaleGetter = physicsScaleGetter;
	export import CubismPhysicsJson = CubismPhysicsJson;
}
declare namespace rendering {
	export import CubismClippingManager = CubismClippingManager;
	export import ICubismClippingManager = ICubismClippingManager;
	export import ClippingContextConstructor = ClippingContextConstructor;
	export import CubismRenderer = CubismRenderer;
	export import CubismTextureColor = CubismTextureColor;
	export import CubismClippingContext = CubismClippingContext;
	export import CubismBlendMode = CubismBlendMode;
	export import CubismClippingManager_WebGL = CubismClippingManager_WebGL;
	export import CubismRenderTextureResource = CubismRenderTextureResource;
	export import CubismClippingContext_WebGL = CubismClippingContext_WebGL;
	export import CubismRendererProfile_WebGL = CubismRendererProfile_WebGL;
	export import CubismRenderer_WebGL = CubismRenderer_WebGL;
	export import CubismShader_WebGL = CubismShader_WebGL;
	export import CubismShaderManager_WebGL = CubismShaderManager_WebGL;
	export import CubismShaderSet = CubismShaderSet;
	export import ShaderNames = ShaderNames;
	export import vertexShaderSrcSetupMask = vertexShaderSrcSetupMask;
	export import fragmentShaderSrcsetupMask = fragmentShaderSrcsetupMask;
	export import vertexShaderSrc = vertexShaderSrc;
	export import vertexShaderSrcMasked = vertexShaderSrcMasked;
	export import fragmentShaderSrcPremultipliedAlpha = fragmentShaderSrcPremultipliedAlpha;
	export import fragmentShaderSrcMaskPremultipliedAlpha = fragmentShaderSrcMaskPremultipliedAlpha;
	export import fragmentShaderSrcMaskInvertedPremultipliedAlpha = fragmentShaderSrcMaskInvertedPremultipliedAlpha;
}
declare namespace type {
	export import csmPair = csmPair;
	export import csmMap = csmMap;
	export import csmRect = csmRect;
	export import csmString = csmString;
	export import csmVector = csmVector;
}
declare namespace utils {
	export import CubismDebug = CubismDebug;
	export import CubismLogPrint = CubismLogPrint;
	export import CubismLogPrintIn = CubismLogPrintIn;
	export import CSM_ASSERT = CSM_ASSERT;
	export import Value = Value;
	export import CubismJson = CubismJson;
	export import JsonFloat = JsonFloat;
	export import JsonBoolean = JsonBoolean;
	export import JsonString = JsonString;
	export import JsonError = JsonError;
	export import JsonNullvalue = JsonNullvalue;
	export import JsonArray = JsonArray;
	export import JsonMap = JsonMap;
	export import CubismJsonExtension = CubismJsonExtension;
	export import CubismString = CubismString;
}

declare namespace Cubism {
	export { CubismFramework, ICubismModelSetting, Live2DCubismFramework, LogLevel, Option$1 as Option, csmDelete, effect, id, math, model, motion, physics, rendering, type, utils };
}

export {
	Cubism,
};

export {};