fmode-ng 0.0.86 → 0.0.87

package/lib/aigc/service-fmai/service-imagine/imagine-func.d.ts

@@ -62,3 +62,21 @@ export interface jimengI_vOptions {
  * @returns 返回ImagineWork作品任务Parse对象
  */
 export declare function getJimengImg(params: jimengImgOptions): Promise<Parse.Object<Parse.Attributes>>;
+/**
+ * 即梦创建文生视频
+ * @param params 视频参数
+ * @returns 返回ImagineWork作品任务Parse对象
+ */
+export declare function getJimengT_v(params: jimengT_vOptions): Promise<any>;
+/**
+ * 即梦创建图生视频
+ * @param params 视频参数
+ * @returns 返回ImagineWork作品任务Parse对象
+ */
+export declare function getJimengI_v(params: jimengI_vOptions): Promise<any>;
+/**
+ * 即梦获取视频
+ * @param params 接口参数 {workId?,taskId?,video_by:text/img}
+ * @returns 返回ImagineWork作品任务Parse对象
+ */
+export declare function getJimengV_data(params: any): Promise<any>;

package/lib/aigc/service-fmai/service-imagine/imagine.service.d.ts

@@ -3,6 +3,7 @@ import { NovaCloudService } from '../../../nova-cloud/nova-cloud.service';
 import Parse from "parse";
 import { NovaUploadService } from '../../../storage/service-upload/nova-upload.service';
 import { DalleOptions, jimengImgOptions } from './imagine-func';
+import { ToastController } from '@ionic/angular';
 import * as i0 from "@angular/core";
 export interface StableDiffusionOptions {
     prompt: string;
@@ -62,10 +63,11 @@ export declare class ImagineService {
     private http;
     private ncloud;
     private uploadServ;
+    private toastCtrl;
     /**
      * 图片生成接口主机地址
      */
-    constructor(http: HttpClient, ncloud: NovaCloudService, uploadServ: NovaUploadService);
+    constructor(http: HttpClient, ncloud: NovaCloudService, uploadServ: NovaUploadService, toastCtrl: ToastController);
     /**
      * DALL-E-3 图片生成函数
      * @description
@@ -117,6 +119,24 @@ export declare class ImagineService {
      * @param options  图像参数
      */
     getJimengImg(options: jimengImgOptions): Promise<void>;
+    /**
+     * 即梦视频生成函数
+     * @param options 图像参数
+     * @param type 类型 文生视频无需填写，图生视频填'i_v'
+     * @returns
+     */
+    getJimengVideo(options: any, type?: any): Promise<void>;
+    /**
+    * 即梦视频请求结果
+    * @param video_by 获取类型：文生视频/图生视频 'text'|'img'
+    * @param workId 作品id
+    */
+    getJimengVideoData(video_by: 'text' | 'img', workId: any): Promise<any>;
+    /**
+     * 提示
+     * @param msg 提示语
+     */
+    setToast(msg: any): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ImagineService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ImagineService>;
 }

package/lib/core/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./agent";
 export * from "./voice";
+export * from "./parse";

package/lib/core/parse/fmode.object.d.ts

@@ -0,0 +1,54 @@
+type ACL = Record<string, {
+    read: boolean;
+    write: boolean;
+}>;
+type Pointer = {
+    __type: 'Pointer';
+    className: string;
+    objectId: string;
+};
+type File = {
+    __type: 'File';
+    name: string;
+    url: string;
+};
+type Relation = {
+    __type: 'Relation';
+    className: string;
+};
+export declare class FmodeObject {
+    static _instance: any | null;
+    static bindInstance(instance: any): void;
+    className: string;
+    id?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    ACL?: ACL;
+    data: Record<string, any>;
+    constructor(className: string);
+    static extend(className: string): typeof FmodeObject;
+    toPointer(): Pointer;
+    toJSON(): Record<string, any>;
+    get(key: string): any;
+    set(key: string | Record<string, any>, value?: any): this;
+    unset(key: string): this;
+    increment(key: string, amount?: number): this;
+    add(key: string, items: any[]): this;
+    addUnique(key: string, items: any[]): this;
+    remove(key: string, items: any[]): this;
+    save(options?: {
+        useMasterKey?: boolean;
+    }): Promise<this>;
+    destroy(options?: {
+        useMasterKey?: boolean;
+    }): Promise<void>;
+    static create<T extends FmodeObject>(className: string, attributes: Record<string, any>, options?: {
+        useMasterKey?: boolean;
+    }): Promise<T>;
+    static fetchAll<T extends FmodeObject>(objects: T[], options?: {
+        useMasterKey?: boolean;
+    }): Promise<T[]>;
+    relation(key: string): Relation;
+    static fromFile(name: string, data: Blob | File | any, type?: string): Promise<File>;
+}
+export {};

package/lib/core/parse/fmode.query.d.ts

@@ -0,0 +1,131 @@
+import { FmodeObject } from './fmode.object';
+type QueryConditions = {
+    $lt?: any;
+    $lte?: any;
+    $gt?: any;
+    $gte?: any;
+    $ne?: any;
+    $in?: any[];
+    $nin?: any[];
+    $exists?: boolean;
+    $select?: any;
+    $dontSelect?: any;
+    $all?: any[];
+    $regex?: RegExp | string;
+    $text?: {
+        $search: string;
+        $caseSensitive?: boolean;
+        $diacriticSensitive?: boolean;
+    };
+    $nearSphere?: any;
+    $within?: any;
+    $maxDistance?: number;
+    $or?: QueryConditions[];
+    $and?: QueryConditions[];
+    [key: string]: any;
+};
+export declare class FmodeQuery<T extends FmodeObject = FmodeObject> {
+    private static _instance;
+    static bindInstance(instance: any): void;
+    private static get instance();
+    className: string;
+    where: QueryConditions;
+    _include: string[];
+    _select: string[];
+    _limit?: number;
+    _skip?: number;
+    _order?: string[];
+    _count: boolean;
+    _keys?: string;
+    _readPreference?: string;
+    _includeReadPreference?: string;
+    _subqueryReadPreference?: string;
+    _explain?: boolean;
+    _hint?: any;
+    _maxTimeMS?: number;
+    _tracing?: boolean;
+    _localDatastore?: boolean;
+    _sessionToken?: string;
+    _context?: any;
+    constructor(className: string | {
+        new (): T;
+    });
+    equalTo(key: string, value: any): this;
+    notEqualTo(key: string, value: any): this;
+    lessThan(key: string, value: any): this;
+    lessThanOrEqualTo(key: string, value: any): this;
+    greaterThan(key: string, value: any): this;
+    greaterThanOrEqualTo(key: string, value: any): this;
+    containedIn(key: string, values: any[]): this;
+    notContainedIn(key: string, values: any[]): this;
+    exists(key: string): this;
+    doesNotExist(key: string): this;
+    containsAll(key: string, values: any[]): this;
+    contains(key: string, substring: string): this;
+    startsWith(key: string, prefix: string): this;
+    endsWith(key: string, suffix: string): this;
+    matches(key: string, regex: RegExp, modifiers?: string): this;
+    matchesQuery(key: string, query: FmodeQuery): this;
+    doesNotMatchQuery(key: string, query: FmodeQuery): this;
+    matchesKeyInQuery(key: string, queryKey: string, query: FmodeQuery): this;
+    doesNotMatchKeyInQuery(key: string, queryKey: string, query: FmodeQuery): this;
+    near(key: string, point: {
+        latitude: number;
+        longitude: number;
+    }): this;
+    withinRadians(key: string, point: {
+        latitude: number;
+        longitude: number;
+    }, distance: number): this;
+    withinMiles(key: string, point: {
+        latitude: number;
+        longitude: number;
+    }, distance: number): this;
+    withinKilometers(key: string, point: {
+        latitude: number;
+        longitude: number;
+    }, distance: number): this;
+    withinGeoBox(key: string, southwest: {
+        latitude: number;
+        longitude: number;
+    }, northeast: {
+        latitude: number;
+        longitude: number;
+    }): this;
+    polygonContains(key: string, points: Array<{
+        latitude: number;
+        longitude: number;
+    }>): this;
+    include(...keys: string[]): this;
+    select(...keys: string[]): this;
+    limit(count: number): this;
+    skip(count: number): this;
+    ascending(...keys: string[]): this;
+    descending(...keys: string[]): this;
+    addAscending(...keys: string[]): this;
+    addDescending(...keys: string[]): this;
+    readPreference(pref: string): this;
+    includeReadPreference(pref: string): this;
+    subqueryReadPreference(pref: string): this;
+    hint(hint: any): this;
+    maxTimeMS(ms: number): this;
+    explain(explain?: boolean): this;
+    withCount(withCount?: boolean): this;
+    find(options?: {
+        useMasterKey?: boolean;
+    }): Promise<T[]>;
+    first(options?: {
+        useMasterKey?: boolean;
+    }): Promise<T | null>;
+    get(objectId: string, options?: {
+        useMasterKey?: boolean;
+    }): Promise<T>;
+    count(options?: {
+        useMasterKey?: boolean;
+    }): Promise<number>;
+    private _buildQueryParams;
+    subscribe(): EventTarget;
+    or: <T_1 extends FmodeObject>(...queries: FmodeQuery<T_1>[]) => FmodeQuery<T_1>;
+    and: <T_1 extends FmodeObject>(...queries: FmodeQuery<T_1>[]) => FmodeQuery<T_1>;
+}
+export {};

package/lib/core/parse/fmode.user.d.ts

@@ -0,0 +1,36 @@
+import { FmodeObject } from './fmode.object';
+export declare class FmodeUser extends FmodeObject {
+    static _instance: any | null;
+    static bindInstance(instance: any): void;
+    private static get instance();
+    sessionToken?: string;
+    email?: string;
+    username?: string;
+    password?: string;
+    constructor(attributes?: Record<string, any>);
+    static signUp(username: string, password: string, attrs?: Record<string, any>): Promise<FmodeUser>;
+    static logIn(username: string, password: string): Promise<FmodeUser>;
+    static logOut(): Promise<void>;
+    static become(sessionToken: string): Promise<FmodeUser>;
+    static requestPasswordReset(email: string): Promise<void>;
+    private static _currentUser;
+    private static _unsafeCurrentUserEnabled;
+    static get currentUser(): FmodeUser | null;
+    static enableUnsafeCurrentUser(): void;
+    static disableUnsafeCurrentUser(): void;
+    static current(): Promise<FmodeUser | null>;
+    static currentAsync: typeof FmodeUser.current;
+    private static _clearCurrentUser;
+    signUp(attrs?: Record<string, any>): Promise<this>;
+    logIn(): Promise<this>;
+    fetch(): Promise<this>;
+    private _saveToCache;
+    private _restoreFromCache;
+    toJSON(): Record<string, any>;
+    save(options?: {
+        useMasterKey?: boolean;
+    }): Promise<this>;
+    destroy(options?: {
+        useMasterKey?: boolean;
+    }): Promise<void>;
+}

package/lib/core/parse/index.d.ts

@@ -0,0 +1,23 @@
+import { FmodeObject } from './fmode.object';
+import { FmodeQuery } from './fmode.query';
+import { FmodeUser } from './fmode.user';
+import { FmodeConfig, FmodeInitOptions } from './types';
+declare class FmodeParse {
+    config: FmodeConfig;
+    private static _instances;
+    private static _defaultInstance;
+    readonly Object: typeof FmodeObject;
+    readonly Query: typeof FmodeQuery;
+    readonly User: typeof FmodeUser;
+    private constructor();
+    static initialize(config: string | FmodeInitOptions): FmodeParse;
+    static with(configName: string): FmodeParse;
+    get serverURL(): string;
+    get appId(): string;
+}
+declare const defaultExport: typeof FmodeParse & {
+    Object: typeof FmodeObject;
+    Query: typeof FmodeQuery;
+    User: typeof FmodeUser;
+};
+export { FmodeParse as default, defaultExport as FmodeParse };

package/lib/core/parse/types.d.ts

@@ -0,0 +1,8 @@
+export interface FmodeConfig {
+    appId: string;
+    serverURL: string;
+    masterKey?: string;
+}
+export interface FmodeInitOptions extends FmodeConfig {
+    configName?: string;
+}

package/lib/person/edit-upload/edit-upload.component.d.ts

@@ -62,7 +62,7 @@ export declare class EditUploadComponent implements OnInit {
     }[];
     qiniuConf: any;
     getUptoken(): Promise<any>;
-    checkFileType(url: string): "video" | "image" | "file";
+    checkFileType(url: string): "file" | "video" | "image";
     upable(): boolean;
     imgShowing: boolean;
     fileUrl: string;

package/lib/user/comp-user-avatar/comp-user-avatar.component.d.ts

@@ -12,7 +12,7 @@ export declare class CompUserAvatarComponent implements OnInit {
     ngOnInit(): void;
     ngOnChanges(): void;
     refresh(): Promise<void>;
-    getType(): "avatar" | "text" | "icon";
+    getType(): "text" | "avatar" | "icon";
     static ɵfac: i0.ɵɵFactoryDeclaration<CompUserAvatarComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CompUserAvatarComponent, "app-comp-user-avatar", never, { "user": { "alias": "user"; "required": false; }; }, {}, never, never, true, never>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fmode-ng",
-  "version": "0.0.86",
+  "version": "0.0.87",
   "author": "未来全栈",
   "license": "COPYRIGHT © 未来飞马 未来全栈 www.fmode.cn All RIGHTS RESERVED",
   "peerDependencies": {