@laiye_packages/uci 1.0.0

package/dist/app/organization/app/index.d.ts

@@ -0,0 +1,30 @@
+import { LYBaseTenantApp } from '../../base';
+import { LYSessionApi } from '../api/session';
+import type { SSOConfig } from '../api/session';
+import { LYUserApi } from '../api/user';
+import type { LYBaseAuthorizer } from '../authorizer/base';
+import { LYLicenseApi } from '../api/license';
+import { LYCrypto } from '../../../crypto';
+import { LYOEMApi } from '../api/oem';
+import { LYVerificationCodesApi } from '../api/verificationCodes';
+declare class LYOrganizationApp extends LYBaseTenantApp {
+    static _instance?: LYOrganizationApp;
+    private _sessionApi;
+    private _userApi;
+    private _licenseApi;
+    private _authorizers;
+    private _oemApi;
+    private _verificationCodesApi;
+    constructor(name: string, version: string, description: string);
+    static get instance(): LYOrganizationApp;
+    get sessionApi(): LYSessionApi;
+    get userApi(): LYUserApi;
+    get oemApi(): LYOEMApi;
+    get licenseApi(): LYLicenseApi;
+    get crypto(): LYCrypto;
+    get verificationCodesApi(): LYVerificationCodesApi;
+    protected doLoad(): Promise<void>;
+    private mergeOEM;
+    getAuthorizer<T extends LYBaseAuthorizer = LYBaseAuthorizer>(name?: string): T;
+}
+export { LYOrganizationApp, SSOConfig };

package/dist/app/organization/authorizer/base.d.ts

@@ -0,0 +1,35 @@
+import { LYObject, type LYEvents } from '../../../object';
+import { LYBaseApp } from '../../base';
+import { SSOConfig } from '../api/session';
+export declare const ORGANIZATION_APP_NAME = "organization";
+export type LYAuthorizerStatus = 'signed-in' | 'signed-out';
+type LYAuthorizerEvents = {
+    'status-change': (status: LYAuthorizerStatus) => void;
+};
+export interface LYSigninArgs {
+    redirect_uri: string;
+    sso_config?: SSOConfig;
+}
+export interface LYSignoutArgs {
+    redirect_uri?: string;
+}
+export interface ILYAuthorizer<TSigninArgs extends LYSigninArgs = LYSigninArgs, TSignoutArgs extends LYSignoutArgs = LYSignoutArgs> {
+    on: LYEvents<LYAuthorizerEvents>['on'];
+    off: LYEvents<LYAuthorizerEvents>['on'];
+    once: LYEvents<LYAuthorizerEvents>['on'];
+    emit: LYEvents<LYAuthorizerEvents>['emit'];
+    signin: (args: TSigninArgs) => Promise<void>;
+    signout: (args: TSignoutArgs) => Promise<void>;
+}
+export declare abstract class LYBaseAuthorizer<TSigninArgs extends LYSigninArgs = LYSigninArgs, TSignoutArgs extends LYSignoutArgs = LYSignoutArgs> extends LYObject implements ILYAuthorizer<TSigninArgs, TSignoutArgs> {
+    private _app;
+    private _name;
+    constructor(app: LYBaseApp, name: string);
+    get app(): LYBaseApp;
+    get name(): string;
+    signin(args: TSigninArgs): Promise<void>;
+    signout(args: TSignoutArgs): Promise<void>;
+    protected abstract _signin(args: TSigninArgs): Promise<void>;
+    protected abstract _signout(args: TSignoutArgs): Promise<void>;
+}
+export {};

package/dist/app/organization/authorizer/direct.d.ts

@@ -0,0 +1,11 @@
+import { LYBaseAuthorizer, type LYSigninArgs, type LYSignoutArgs } from './base';
+interface LYDirectSigninArgs extends LYSigninArgs {
+    authentication_name: string;
+    user_name: string;
+    password: string;
+}
+export declare class LYDirectAuthorizer extends LYBaseAuthorizer {
+    _signin(args: LYDirectSigninArgs): Promise<void>;
+    _signout(args: LYSignoutArgs): Promise<void>;
+}
+export {};

package/dist/app/organization/authorizer/gateway.d.ts

@@ -0,0 +1,5 @@
+import { LYBaseAuthorizer, type LYSigninArgs, type LYSignoutArgs } from './base';
+export declare class LYGatewayAuthorizer extends LYBaseAuthorizer {
+    _signin(args: LYSigninArgs): Promise<void>;
+    _signout(args: LYSignoutArgs): Promise<void>;
+}

package/dist/app/organization/authorizer/redirect.d.ts

@@ -0,0 +1,18 @@
+import { LYBaseAuthorizer, type LYSigninArgs, LYSignoutArgs } from './base';
+export interface LYRedirectSessionPostRequest {
+    authentication_name: string;
+    query_params: {
+        code: string;
+        code_verifier: string;
+        redirect_uri: string;
+        state: string;
+    };
+}
+export declare class LYRedirectAuthorizer extends LYBaseAuthorizer {
+    _signin(args: LYSigninArgs): Promise<void>;
+    signin(args: LYSigninArgs): Promise<void>;
+    private _jumpToSSO;
+    private _getQueryParams;
+    signout(args?: LYSignoutArgs): Promise<void>;
+    _signout(): Promise<void>;
+}

package/dist/app/organization/authorizer/web.d.ts

@@ -0,0 +1,25 @@
+import type { LYBaseApp } from '../../base';
+import { LYBaseAuthorizer, type LYSigninArgs, type LYSignoutArgs } from './base';
+import type { LYSessionApi } from '../api/session';
+export interface LYWebSigninArgs extends LYSigninArgs {
+    name?: string;
+    password?: string;
+    email?: string;
+    phone?: string;
+    country_code?: string;
+    account_type?: "email" | "phone";
+    verification_code?: string;
+    verification_code_id?: string;
+}
+export interface LYWebSignoutArgs extends LYSignoutArgs {
+}
+export declare class LYWebAuthorizer extends LYBaseAuthorizer<LYWebSigninArgs, LYWebSignoutArgs> {
+    private _sessionApi;
+    constructor(app: LYBaseApp, name: string, sessionApi: LYSessionApi);
+    _signin(args: LYWebSigninArgs): Promise<void>;
+    _signout(args: LYWebSignoutArgs): Promise<void>;
+    /**
+     * 刷新session
+     */
+    private _refreshSession;
+}

package/dist/app/organization/index.d.ts

@@ -0,0 +1 @@
+export * from './app';

package/dist/app/tenant/api/configuration.d.ts

@@ -0,0 +1,8 @@
+import type { LYAppHttpClient } from '../../../http';
+export declare class LYConfigurationApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    get_meta(): Promise<Record<string, any>>;
+    get(): Promise<Record<string, any>>;
+    set(value: Record<string, any>): Promise<number>;
+}

package/dist/app/tenant/api/session.d.ts

@@ -0,0 +1,23 @@
+import type { LYAppHttpClient, LYBaseResponse } from '../../../http';
+interface LYSessionResponse extends LYBaseResponse {
+    id: string;
+    access_token: string;
+    token_type: string;
+    user_id: string;
+    user_name: string;
+    expires_in: number;
+    claims: Record<string, any>;
+}
+interface LYSessionPostRequest {
+    name: string;
+    password: string;
+}
+export declare class LYSessionApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    get(id: string): Promise<LYSessionResponse>;
+    create(session: LYSessionPostRequest): Promise<LYSessionResponse>;
+    update(id: string): Promise<LYSessionResponse>;
+    delete(id: string): Promise<number>;
+}
+export {};

package/dist/app/tenant/api/tenant.d.ts

@@ -0,0 +1,25 @@
+import type { LYAppHttpClient, LYBaseResponse } from '../../../http';
+interface LYTenantResponse extends LYBaseResponse {
+    id: string;
+    name: string;
+    description: string;
+}
+interface LYTenantPostRequest {
+    name: string;
+    description?: string;
+    admin_name: string;
+    admin_password: string;
+}
+interface LYTenantPatchRequest {
+    description?: string;
+}
+export declare class LYTenantApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    query(): Promise<LYTenantResponse[]>;
+    get(name: string): Promise<LYTenantResponse>;
+    create(tenant: LYTenantPostRequest): Promise<string>;
+    update(name: string, tenant: LYTenantPatchRequest): Promise<number>;
+    delete(name: string): Promise<number>;
+}
+export {};

package/dist/app/tenant/api/user.d.ts

@@ -0,0 +1,27 @@
+import type { LYAppHttpClient, LYBaseResponse, LYListResponse } from '../../../http';
+interface LYUserResponse extends LYBaseResponse {
+    id: string;
+    name: string;
+    description: string;
+}
+interface LYUserListResponse extends LYListResponse<LYUserResponse> {
+}
+interface LYUserPostRequest {
+    name: string;
+    password: string;
+    description?: string;
+}
+interface LYUserPatchRequest {
+    password?: string;
+    description?: string;
+}
+export declare class LYUserApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    query(): Promise<LYUserListResponse>;
+    get(name: string): Promise<LYUserResponse>;
+    create(user: LYUserPostRequest): Promise<string>;
+    update(name: string, user: LYUserPatchRequest): Promise<number>;
+    delete(name: string): Promise<number>;
+}
+export {};

package/dist/app/tenant/app/index.d.ts

@@ -0,0 +1,20 @@
+import { LYBaseApp } from '../../base';
+import { LYTenantApi } from '../api/tenant';
+import { LYUserApi } from '../api/user';
+import { LYConfigurationApi } from '../api/configuration';
+import { LYTenantAuthorizer } from '../authorizer';
+declare class LYTenantApp extends LYBaseApp {
+    static _instance?: LYTenantApp;
+    private _tenantApi;
+    private _userApi;
+    private _configuration;
+    private _authorizer;
+    constructor(name: string, version: string, description: string);
+    static get instance(): LYTenantApp;
+    get tenantApi(): LYTenantApi;
+    get userApi(): LYUserApi;
+    get configuration(): LYConfigurationApi;
+    get authorizer(): LYTenantAuthorizer;
+    protected doLoad(): Promise<void>;
+}
+export { LYTenantApp };

package/dist/app/tenant/authorizer/index.d.ts

@@ -0,0 +1,13 @@
+import { LYObject } from '../../../object';
+import type { LYAppHttpClient } from '../../../http';
+export declare class LYTenantAuthorizer extends LYObject {
+    private _sessionApi;
+    constructor(httpClient: LYAppHttpClient);
+    signin(userName: string, password: string): Promise<void>;
+    signout(): Promise<void>;
+    update(): Promise<void>;
+    /**
+     * 刷新session
+     */
+    private _refreshSession;
+}

package/dist/app/tenant/index.d.ts

@@ -0,0 +1 @@
+export * from './app';

package/dist/app/tenant/session/index.d.ts

@@ -0,0 +1,57 @@
+import { LYObject } from '../../../object';
+export declare class LYTenantSession extends LYObject {
+    private static _session?;
+    private _id;
+    private _token;
+    private _user_id;
+    private _user_name;
+    private _expires_in;
+    private _claims;
+    private _created_at;
+    private static _refreshCallback?;
+    private static _refreshTimer?;
+    private static readonly _CHECK_INTERVAL;
+    static get(): LYTenantSession | undefined;
+    static create(id: string, token: string, user_id: string, user_name: string, expires_in: number, claims: Record<string, any>): LYTenantSession;
+    static clear(): void;
+    constructor(id: string, token: string, user_id: string, user_name: string, expires_in: number, claims: Record<string, any>, created_at: number);
+    get id(): string;
+    get token(): string;
+    get user_id(): string;
+    get user_name(): string;
+    get expires_in(): number;
+    get claims(): Record<string, any>;
+    get created_at(): number;
+    /**
+     * 检查session是否已过期
+     */
+    isExpired(): boolean;
+    /**
+     * 检查session是否即将过期（在过期前15秒）
+     */
+    isNearExpiration(): boolean;
+    /**
+     * 设置刷新回调函数
+     */
+    static setRefreshCallback(callback: (session: LYTenantSession) => Promise<void>): void;
+    /**
+     * 获取有效的session，如果过期则尝试刷新
+     */
+    static getValid(): Promise<LYTenantSession | undefined>;
+    /**
+     * 更新session信息
+     */
+    static update(id: string, token: string, user_id: string, user_name: string, expires_in: number, claims: Record<string, any>): void;
+    /**
+     * 启动定时器监控session过期
+     */
+    private static _startRefreshTimer;
+    /**
+     * 停止定时器
+     */
+    private static _stopRefreshTimer;
+    /**
+     * 检查并刷新session
+     */
+    private static _checkAndRefreshSession;
+}

package/dist/config/address.d.ts

@@ -0,0 +1,5 @@
+import { LYBaseConfigModel } from './base';
+export declare class LYAddressConfig extends LYBaseConfigModel {
+    tenantLoginUrl: string;
+    organizationLoginUrl: string;
+}

package/dist/config/app.d.ts

@@ -0,0 +1,5 @@
+import { LYBaseConfigModel } from './base';
+export declare class LYAppConfig extends LYBaseConfigModel {
+    name: string;
+    version: string;
+}

package/dist/config/base.d.ts

@@ -0,0 +1,15 @@
+import { LYObject } from '../object';
+export declare function model<T extends typeof LYBaseConfigModel>(modelType: T): (target: any, key: string) => void;
+export declare function array<T extends typeof LYBaseConfigModel>(modelType: T): (target: any, key: string) => void;
+export declare function object<T extends typeof LYBaseConfigModel>(modelType: T): (target: any, key: string) => void;
+export declare class LYBaseConfigModel {
+    clone(): this;
+    load(config: Record<string, any>): void;
+}
+export declare class LYBaseConfig extends LYObject {
+    static load<T extends typeof LYBaseConfig>(this: T, config_url: string): Promise<InstanceType<T>>;
+    static get<T extends typeof LYBaseConfig>(this: T): InstanceType<T>;
+    private _load_from_url;
+    private _load_from_element;
+    load(config_url: string): Promise<void>;
+}

package/dist/config/crypto.d.ts

@@ -0,0 +1,5 @@
+import { LYBaseConfigModel } from './base';
+export type LYCryptoType = 'default' | 'sm' | 'gm';
+export declare class LYCryptoConfig extends LYBaseConfigModel {
+    type: LYCryptoType;
+}

package/dist/config/http.d.ts

@@ -0,0 +1,14 @@
+import { LYBaseConfigModel } from './base';
+export declare class LYRetryWaitExponential extends LYBaseConfigModel {
+    multiplier: number;
+    min: number;
+    max: number;
+}
+export declare class LYHttpRetryConfig extends LYBaseConfigModel {
+    timeoutPerRetry: number;
+    stopAfterDelay: number;
+    waitExponential: LYRetryWaitExponential;
+}
+export declare class LYHttpConfig extends LYBaseConfigModel {
+    retry: LYHttpRetryConfig;
+}

package/dist/config/index.d.ts

@@ -0,0 +1,12 @@
+import { LYBaseConfig } from './base';
+import { LYHttpConfig } from './http';
+import { LYCryptoConfig } from './crypto';
+import { LYAppConfig } from './app';
+import { LYAddressConfig } from './address';
+export declare class LYConfig extends LYBaseConfig {
+    http: LYHttpConfig;
+    crypto: LYCryptoConfig;
+    apps: LYAppConfig[];
+    address: LYAddressConfig;
+    host_patterns: string[];
+}

package/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const FRAMEWORK_NAME = "uci";

package/dist/crypto/base.d.ts

@@ -0,0 +1,14 @@
+import { LYCryptoType } from "../config/crypto";
+export declare abstract class LYBaseCrypto {
+    abstract getSymmetricBlockSize(iv: Uint8Array, key: Uint8Array): number;
+    abstract getAsymmetricBlockSize(publicKey: Uint8Array): number;
+    abstract encryptSymmetric(data: Uint8Array, iv: Uint8Array, key: Uint8Array): Uint8Array;
+    abstract decryptSymmetric(data: Uint8Array, iv: Uint8Array, key: Uint8Array): Uint8Array;
+    abstract signature(data: Uint8Array, privateKey: Uint8Array): string;
+    abstract verify(data: Uint8Array, publicKey: Uint8Array, signature: string): boolean;
+    abstract encryptAsymmetric(data: Uint8Array, publicKey: Uint8Array): Uint8Array;
+    abstract decryptAsymmetric(data: Uint8Array, privateKey: Uint8Array): Uint8Array;
+    abstract hash(data: Uint8Array, key?: Uint8Array): Uint8Array;
+}
+export declare function registerCryptoImpl(name: LYCryptoType): <T extends new () => LYBaseCrypto>(impl: T) => T;
+export declare const cryptoImpl: Record<LYCryptoType, new () => LYBaseCrypto | undefined>;

package/dist/crypto/gm.d.ts

@@ -0,0 +1,3 @@
+import { LYSMCrypto } from "./sm";
+export declare class LYGMCrypto extends LYSMCrypto {
+}

package/dist/crypto/index.d.ts

@@ -0,0 +1,144 @@
+import { LYObject } from "../object";
+import { LYBaseCrypto } from "./base";
+import "./sm";
+import "./gm";
+export declare class LYCrypto extends LYObject {
+    private _impl?;
+    private _encryptPublicKey?;
+    private _decryptPrivateKey?;
+    private _signaturePrivateKey?;
+    private _verifyPublicKey?;
+    private _ivGetter;
+    private _keyGetter;
+    constructor();
+    get impl(): LYBaseCrypto;
+    private _createImpl;
+    private _getCryptoConfig;
+    private _uint8ArrayToHex;
+    private _hexToUint8Array;
+    private _stringToUint8Array;
+    private _uint8ArrayToString;
+    private _base64ToUint8Array;
+    private _uint8ArrayToBase64;
+    private _getIvAndKey;
+    private _getKey;
+    private _getEncryptPublicKey;
+    private _getDecryptPrivateKey;
+    private _getSignaturePrivateKey;
+    private _getVerifyPublicKey;
+    /**
+     * 将数据流分成指定大小的块
+     */
+    private _makeSize;
+    /**
+     * 设置对称加密的IV和密钥获取函数
+     */
+    setSymmetricKeyGetter(ivGetter: () => Uint8Array, keyGetter: () => Uint8Array): void;
+    /**
+     * 设置非对称加密公钥
+     */
+    setEncryptPublicKey(publicKey: Uint8Array | string): void;
+    /**
+     * 设置非对称解密私钥
+     */
+    setDecryptPrivateKey(privateKey: Uint8Array | string): void;
+    /**
+     * 设置签名私钥
+     */
+    setSignaturePrivateKey(privateKey: Uint8Array | string): void;
+    /**
+     * 设置验证公钥
+     */
+    setVerifyPublicKey(publicKey: Uint8Array | string): void;
+    /**
+     * 对称加密 - 字节数组
+     */
+    encryptSymmetric(data: Uint8Array, iv?: Uint8Array | string, key?: Uint8Array | string): Uint8Array;
+    /**
+     * 对称加密 - 字符串
+     */
+    encryptSymmetric(data: string, iv?: Uint8Array | string, key?: Uint8Array | string): string;
+    /**
+     * 对称加密 - 流式数据
+     */
+    encryptSymmetric(data: AsyncIterable<Uint8Array>, iv?: Uint8Array | string, key?: Uint8Array | string): AsyncIterable<Uint8Array>;
+    private _encryptSymmetricBytes;
+    private _encryptSymmetricStr;
+    private _encryptSymmetricStream;
+    /**
+     * 对称解密 - 字节数组
+     */
+    decryptSymmetric(data: Uint8Array, iv?: Uint8Array | string, key?: Uint8Array | string): Uint8Array;
+    /**
+     * 对称解密 - 字符串
+     */
+    decryptSymmetric(data: string, iv?: Uint8Array | string, key?: Uint8Array | string): string;
+    /**
+     * 对称解密 - 流式数据
+     */
+    decryptSymmetric(data: AsyncIterable<Uint8Array>, iv?: Uint8Array | string, key?: Uint8Array | string): AsyncIterable<Uint8Array>;
+    private _decryptSymmetricBytes;
+    private _decryptSymmetricStr;
+    private _decryptSymmetricStream;
+    /**
+     * 非对称加密 - 字节数组
+     */
+    encryptAsymmetric(data: Uint8Array, publicKey?: Uint8Array | string): Uint8Array;
+    /**
+     * 非对称加密 - 字符串
+     */
+    encryptAsymmetric(data: string, publicKey?: Uint8Array | string): string;
+    /**
+     * 非对称加密 - 流式数据
+     */
+    encryptAsymmetric(data: AsyncIterable<Uint8Array>, publicKey?: Uint8Array | string): AsyncIterable<Uint8Array>;
+    private _encryptAsymmetricBytes;
+    private _encryptAsymmetricStr;
+    private _encryptAsymmetricStream;
+    /**
+     * 非对称解密 - 字节数组
+     */
+    decryptAsymmetric(data: Uint8Array, privateKey?: Uint8Array | string): Uint8Array;
+    /**
+     * 非对称解密 - 字符串
+     */
+    decryptAsymmetric(data: string, privateKey?: Uint8Array | string): string;
+    /**
+     * 非对称解密 - 流式数据
+     */
+    decryptAsymmetric(data: AsyncIterable<Uint8Array>, privateKey?: Uint8Array | string): AsyncIterable<Uint8Array>;
+    private _decryptAsymmetricBytes;
+    private _decryptAsymmetricStr;
+    private _decryptAsymmetricStream;
+    /**
+     * 签名 - 字节数组
+     */
+    signature(data: Uint8Array, privateKey?: Uint8Array | string): string;
+    /**
+     * 签名 - 字符串
+     */
+    signature(data: string, privateKey?: Uint8Array | string): string;
+    private _signatureBytes;
+    private _signatureStr;
+    /**
+     * 验证签名 - 字节数组
+     */
+    verify(data: Uint8Array, signature: string, publicKey?: Uint8Array | string): boolean;
+    /**
+     * 验证签名 - 字符串
+     */
+    verify(data: string, signature: string, publicKey?: Uint8Array | string): boolean;
+    private _verifyBytes;
+    private _verifyStr;
+    /**
+     * 哈希 - 字节数组
+     */
+    hash(data: Uint8Array, key?: Uint8Array | string, iterations?: number): Uint8Array;
+    /**
+     * 哈希 - 字符串
+     */
+    hash(data: string, key?: Uint8Array | string, iterations?: number): string;
+    private _hashBytes;
+    private _hashStr;
+}
+export declare const crypto: LYCrypto;

package/dist/crypto/sm.d.ts

@@ -0,0 +1,17 @@
+import { LYBaseCrypto } from "./base";
+export declare class LYSMCrypto extends LYBaseCrypto {
+    private _paddingIv;
+    private _uint8ArrayToHex;
+    private _hexToUint8Array;
+    private _validateKey;
+    private _validatePublicKey;
+    getSymmetricBlockSize(iv: Uint8Array, key: Uint8Array): number;
+    getAsymmetricBlockSize(publicKey: Uint8Array): number;
+    encryptSymmetric(data: Uint8Array, iv: Uint8Array, key: Uint8Array): Uint8Array;
+    decryptSymmetric(data: Uint8Array, iv: Uint8Array, key: Uint8Array): Uint8Array;
+    signature(data: Uint8Array, privateKey: Uint8Array): string;
+    verify(data: Uint8Array, publicKey: Uint8Array, signature: string): boolean;
+    encryptAsymmetric(data: Uint8Array, publicKey: Uint8Array): Uint8Array;
+    decryptAsymmetric(data: Uint8Array, privateKey: Uint8Array): Uint8Array;
+    hash(data: Uint8Array, key?: Uint8Array): Uint8Array;
+}

package/dist/env/index.d.ts

@@ -0,0 +1,76 @@
+import type { ILYEvents, LYEvents } from '../object';
+import { LYObject } from '../object';
+type LYEnvEvents = {
+    change(key: string): void;
+};
+export declare const REMOTE_ENTRY = "remoteComponentEntry.js";
+export declare const REMOTE_MODULE = "Index";
+export interface ILYEnv extends ILYEvents<LYEnvEvents> {
+    get(key: string, def?: unknown): unknown;
+    set(key: string, value: unknown): void;
+    has(key: string): boolean;
+    on: LYEvents<LYEnvEvents>['on'];
+    off: LYEvents<LYEnvEvents>['on'];
+    once: LYEvents<LYEnvEvents>['on'];
+    addListener: LYEvents<LYEnvEvents>['on'];
+    removeListener: LYEvents<LYEnvEvents>['on'];
+    emit: LYEvents<LYEnvEvents>['emit'];
+    readonly version: string;
+    readonly buildVersion: string;
+    readonly isOem: boolean;
+    readonly brand: string;
+    readonly product: string;
+    readonly embedProduct: string;
+    readonly baseUrl: string;
+    readonly isRemote: boolean;
+    readonly isIframe: boolean;
+    readonly isElectron: boolean;
+    readonly supportLanguages: string[];
+    [key: string]: any;
+}
+export declare class LYEnv extends LYObject implements ILYEnv {
+    on: LYEvents<LYEnvEvents>['on'];
+    off: LYEvents<LYEnvEvents>['on'];
+    once: LYEvents<LYEnvEvents>['on'];
+    addListener: LYEvents<LYEnvEvents>['on'];
+    removeListener: LYEvents<LYEnvEvents>['on'];
+    emit: LYEvents<LYEnvEvents>['emit'];
+    [key: string]: any;
+    private _isOem;
+    private _brand;
+    private _baseUrl;
+    private _version;
+    private _buildVersion;
+    private _product;
+    private _embedProduct;
+    private _isRemote;
+    private _supportLanguages;
+    constructor(product: string);
+    static getInstance<T extends LYObject>(product: string): T;
+    set(key: string, value: unknown): void;
+    get(key: string, def?: unknown): unknown;
+    has(key: string): boolean;
+    get version(): string;
+    set version(value: string);
+    get buildVersion(): string;
+    set buildVersion(value: string);
+    get isOem(): boolean;
+    set isOem(value: boolean);
+    get brand(): string;
+    set brand(value: string);
+    get product(): string;
+    set product(value: string);
+    get embedProduct(): string;
+    set embedProduct(value: string);
+    get baseUrl(): string;
+    set baseUrl(value: string);
+    get isRemote(): boolean;
+    set isRemote(value: boolean);
+    get isIframe(): boolean;
+    get isElectron(): boolean;
+    get supportLanguages(): string[];
+    set supportLanguages(value: string[]);
+}
+export declare const isIframe: boolean;
+export declare const isElectron: boolean;
+export {};

package/dist/error/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LY系列错误基类
+ */
+export declare class LYError extends Error {
+    private _details?;
+    protected _code: string;
+    constructor(message: string, code?: string, details?: any);
+    get code(): string;
+    get details(): any;
+}
+/**
+ * 加密相关错误类
+ */
+export declare class LYCryptoError extends LYError {
+    constructor(message: string, code?: string, details?: any);
+}