@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/use-model.d.ts

@@ -1,254 +1,172 @@
 export default useModel;
+export type BaseModelClass = typeof import("./base-model.js").default;
+export type BaseModelInstance = {
+    abilities: import("./base-model.js").ModelAbilityMap;
+    changes: import("./base-model.js").ModelDataMap;
+    collection: import("./collection.js").default<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: import("./base-model.js").ModelDataMap;
+    newRecord: boolean;
+    previousModelData: any;
+    preloadedRelationships: import("./base-model.js").PreloadedRelationshipMap;
+    relationshipsCache: import("./base-model.js").LoadedRelationshipMap;
+    relationships: import("./base-model.js").LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    assignAttributes(newAttributes: ModelDataMap): void;
+    attributes(): ModelDataMap;
+    can(givenAbilityName: string): boolean;
+    clone(): /*elided*/ any;
+    cacheKey(): number | string;
+    localCacheKey(): string;
+    fullCacheKey(): string;
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    destroy(): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+    getAttributes(): ModelDataMap;
+    handleResponseError(response: ModelCommandResponse): never;
+    identifierKey(): number | string;
+    isAssociationLoaded(associationName: string): boolean;
+    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+    isAssociationPresent(associationName: string): boolean;
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+    isAttributeChanged(attributeName: string): boolean;
+    isChanged(): boolean;
+    isNewRecord(): boolean;
+    isPersisted(): boolean;
+    savedChangeToAttribute(attributeName: string): boolean;
+    setNewModel(model: /*elided*/ any): void;
+    setNewModelData(model: /*elided*/ any): void;
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    modelClassData(): ModelClassDataType;
+    reload(): Promise<void>;
+    save(): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        response: ModelCommandResponse;
+        model: /*elided*/ any;
+    }>;
+    isValid(): never;
+    isValidOnServer(): Promise<{
+        valid: boolean;
+        errors: ValidationResponseErrors;
+    }>;
+    modelClass(): BaseModelClassType;
+    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+    markForDestruction(): void;
+    markedForDestruction(): boolean;
+    uniqueKey(): number;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    isAttributeLoaded(attributeName: string): boolean;
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+    _readPreloadedRelationships(preloaded: {
+        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+    }): void;
+    primaryKey(): number | string;
+};
+export type BaseModelWithId = BaseModelInstance & {
+    id: () => number | string;
+};
+export type ModelCollection = import("./collection.js").default<any>;
+export type UseModelQueryParams = Record<string, string | number | boolean | object | undefined>;
+export type UseModelCacheValue = string | number | boolean | object | null | undefined;
+export type UseModelMatchParams = Record<string, string | number | undefined>;
+export type UseModelMatch = {
+    params: UseModelMatchParams;
+};
+export type UseModelDefaults = Record<string, string | number | boolean | object | undefined>;
+export type UseModelNewIfNoIdConfig = {
+    defaults?: () => UseModelDefaults | Promise<UseModelDefaults>;
+};
+export type UseModelModelClassResolver = {
+    callback: (args: {
+        queryParams: UseModelQueryParams | undefined;
+    }) => BaseModelClass;
+};
+export type UseModelArgsFactoryArgs = {
+    modelClass: BaseModelClass;
+};
+export type UseModelOnDestroyedArgs = {
+    model: BaseModelInstance;
+} & Record<string, BaseModelInstance>;
+export type UseModelEvents = {
+    addListener: (eventName: string, callback: () => void) => void;
+    removeListener: (eventName: string, callback: () => void) => void;
+};
 export type useModelArgs = {
-    callback?: (arg: object) => Function;
-    args?: (arg: object) => object;
+    active?: boolean;
+    abilities?: Record<string, string[]>;
+    cacheArgs?: UseModelCacheValue[];
+    eventUpdated?: boolean;
+    events?: UseModelEvents;
     loadByQueryParam?: (args: {
-        queryParams: Record<string, any> | undefined;
-    }) => number | string;
-    cacheArgs?: any[];
-    match?: {
-        params: object;
-    };
-    onDestroyed?: (ctx: {
-        model: {
-            changes: {};
-            newRecord: boolean;
-            relationshipsCache: {};
-            relationships: {};
-            abilities: Record<string, any>;
-            modelData: {};
-            assignAttributes(newAttributes: Record<string, any>): void;
-            attributes(): Record<string, any>;
-            can(givenAbilityName: string): boolean;
-            clone(): /*elided*/ any;
-            cacheKey(): number | string;
-            localCacheKey(): string;
-            fullCacheKey(): string;
-            create(attributes?: Record<string, any>, options?: object): Promise<{
-                model: /*elided*/ any;
-                response: object;
-            }>;
-            createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
-                model: /*elided*/ any;
-                response: any;
-            }>;
-            destroy(): Promise<{
-                model: /*elided*/ any;
-                response: object;
-            }>;
-            ensureAbilities(listOfAbilities: string[]): Promise<void>;
-            getAttributes(): Record<string, any>;
-            handleResponseError(response: object): never;
-            identifierKey(): number | string;
-            _identifierKey: string | number;
-            isAssociationLoaded(associationName: string): boolean;
-            isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
-            isAssociationPresent(associationName: string): boolean;
-            ensureAssociationLoaded(associationName: string): Promise<any>;
-            ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
-            isAttributeChanged(attributeName: string): boolean;
-            isChanged(): boolean;
-            isNewRecord(): boolean;
-            isPersisted(): boolean;
-            savedChangeToAttribute(attributeName: string): boolean;
-            setNewModel(model: /*elided*/ any): void;
-            setNewModelData(model: /*elided*/ any): void;
-            previousModelData: any;
-            _isDateChanged(oldValue: any, newValue: any): boolean | void;
-            _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
-            _isStringChanged(oldValue: any, newValue: any): boolean | void;
-            modelClassData(): ModelClassDataType;
-            reload(): Promise<void>;
-            save(): Promise<{
-                model: /*elided*/ any;
-                response?: object;
-            }>;
-            saveRaw(rawData: any, options?: {}): Promise<{
-                model: /*elided*/ any;
-                response: object;
-            }>;
-            update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
-                model: /*elided*/ any;
-                response?: object;
-            }>;
-            _refreshModelFromResponse(response: object): void;
-            _refreshModelDataFromResponse(response: object): void;
-            updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
-                simpleModelErrors?: boolean;
-            }): Promise<{
-                response: object;
-                model: /*elided*/ any;
-            }>;
-            isValid(): never;
-            isValidOnServer(): Promise<{
-                valid: boolean;
-                errors: Record<string, any>;
-            }>;
-            modelClass(): Record<string, any>;
-            preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
-            markForDestruction(): void;
-            _markedForDestruction: boolean;
-            markedForDestruction(): boolean;
-            uniqueKey(): number;
-            uniqueKeyValue: number;
-            _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
-            readAttribute(attributeName: string): any;
-            readAttributeUnderscore(attributeName: string): any;
-            isAttributeLoaded(attributeName: any): boolean;
-            _isPresent(value: any): boolean;
-            _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
-            _readBelongsToReflection({ reflectionName }: {
-                modelClass: any;
-                reflectionName: string;
-            }): any | null;
-            _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
-            _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
-            _readHasOneReflection({ reflectionName }: {
-                modelClass: any;
-                reflectionName: string;
-            }): any | null;
-            _readModelDataFromArgs(args?: {
-                data?: {
-                    b?: Record<string, any>;
-                    a?: Record<string, any>;
-                    r?: any;
-                };
-                collection?: import("./collection.js").default<any>;
-            }): void;
-            collection: import("./collection.js").default<any>;
-            preloadedRelationships: any;
-            _readPreloadedRelationships(preloaded: {
-                getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
-            }): void;
-            primaryKey(): number | string;
-        };
-    }) => void;
-    query?: import("./collection.js").default<any>;
+        queryParams: UseModelQueryParams | undefined;
+    }) => number | string | undefined;
+    match?: UseModelMatch;
+    newIfNoId?: UseModelNewIfNoIdConfig | boolean;
+    newAttributes?: UseModelDefaults;
+    onDestroyed?: (ctx: UseModelOnDestroyedArgs) => void;
+    optional?: boolean;
+    preload?: string[] | object;
+    query?: ModelCollection;
+    select?: string[] | object;
+};
+export type UseModelArgsArg = useModelArgs | ((args: UseModelArgsFactoryArgs) => useModelArgs);
+export type UseModelShapeHookProps = {
+    argsArg?: UseModelArgsArg;
+    modelClassArg: BaseModelClass | UseModelModelClassResolver;
 };
 export type UseModelState = {
-    model: any | undefined;
+    model: BaseModelInstance | undefined;
     notFound: boolean | undefined;
 };
+export type UseModelResult = {
+    model: BaseModelInstance | undefined;
+    modelId: number | string | undefined;
+    notFound: boolean | undefined;
+} & Record<string, BaseModelInstance | number | string | boolean | undefined>;
 /**
- * @param {Function|object} modelClassArg
- * @param {object | ((args: {modelClass: typeof import("./base-model.js").default}) => useModelArgs)} [argsArg]
- * @returns {Record<string, any>}
+ * useModel.
+ * @param {BaseModelClass | UseModelModelClassResolver} modelClassArg
+ * @param {UseModelArgsArg} [argsArg]
+ * @returns {UseModelResult}
  */
-/** useModel. */
-declare function useModel(modelClassArg: any, argsArg?: {}): {
-    model: {
-        changes: {};
-        newRecord: boolean;
-        relationshipsCache: {};
-        relationships: {};
-        abilities: Record<string, any>;
-        modelData: {};
-        assignAttributes(newAttributes: Record<string, any>): void;
-        attributes(): Record<string, any>;
-        can(givenAbilityName: string): boolean;
-        clone(): /*elided*/ any;
-        cacheKey(): number | string;
-        localCacheKey(): string;
-        fullCacheKey(): string;
-        create(attributes?: Record<string, any>, options?: object): Promise<{
-            model: /*elided*/ any;
-            response: object;
-        }>;
-        createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
-            model: /*elided*/ any;
-            response: any;
-        }>;
-        destroy(): Promise<{
-            model: /*elided*/ any;
-            response: object;
-        }>;
-        ensureAbilities(listOfAbilities: string[]): Promise<void>;
-        getAttributes(): Record<string, any>;
-        handleResponseError(response: object): never;
-        identifierKey(): number | string;
-        _identifierKey: string | number;
-        isAssociationLoaded(associationName: string): boolean;
-        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
-        isAssociationPresent(associationName: string): boolean;
-        ensureAssociationLoaded(associationName: string): Promise<any>;
-        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
-        isAttributeChanged(attributeName: string): boolean;
-        isChanged(): boolean;
-        isNewRecord(): boolean;
-        isPersisted(): boolean;
-        savedChangeToAttribute(attributeName: string): boolean;
-        setNewModel(model: /*elided*/ any): void;
-        setNewModelData(model: /*elided*/ any): void;
-        previousModelData: any;
-        _isDateChanged(oldValue: any, newValue: any): boolean | void;
-        _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
-        _isStringChanged(oldValue: any, newValue: any): boolean | void;
-        modelClassData(): ModelClassDataType;
-        reload(): Promise<void>;
-        save(): Promise<{
-            model: /*elided*/ any;
-            response?: object;
-        }>;
-        saveRaw(rawData: any, options?: {}): Promise<{
-            model: /*elided*/ any;
-            response: object;
-        }>;
-        update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
-            model: /*elided*/ any;
-            response?: object;
-        }>;
-        _refreshModelFromResponse(response: object): void;
-        _refreshModelDataFromResponse(response: object): void;
-        updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
-            simpleModelErrors?: boolean;
-        }): Promise<{
-            response: object;
-            model: /*elided*/ any;
-        }>;
-        isValid(): never;
-        isValidOnServer(): Promise<{
-            valid: boolean;
-            errors: Record<string, any>;
-        }>;
-        modelClass(): Record<string, any>;
-        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
-        markForDestruction(): void;
-        _markedForDestruction: boolean;
-        markedForDestruction(): boolean;
-        uniqueKey(): number;
-        uniqueKeyValue: number;
-        _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
-        readAttribute(attributeName: string): any;
-        readAttributeUnderscore(attributeName: string): any;
-        isAttributeLoaded(attributeName: any): boolean;
-        _isPresent(value: any): boolean;
-        _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
-        _readBelongsToReflection({ reflectionName }: {
-            modelClass: any;
-            reflectionName: string;
-        }): any | null;
-        _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
-        _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
-        _readHasOneReflection({ reflectionName }: {
-            modelClass: any;
-            reflectionName: string;
-        }): any | null;
-        _readModelDataFromArgs(args?: {
-            data?: {
-                b?: Record<string, any>;
-                a?: Record<string, any>;
-                r?: any;
-            };
-            collection?: import("./collection.js").default<any>;
-        }): void;
-        collection: import("./collection.js").default<any>;
-        preloadedRelationships: any;
-        _readPreloadedRelationships(preloaded: {
-            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
-        }): void;
-        primaryKey(): number | string;
-    };
-    modelId: string | number;
-    notFound: boolean;
-};
+declare function useModel(modelClassArg: BaseModelClass | UseModelModelClassResolver, argsArg?: UseModelArgsArg): UseModelResult;
 //# sourceMappingURL=use-model.d.ts.map

package/build/use-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-model.d.ts","sourceRoot":"/src/","sources":["use-model.js"],"names":[],"mappings":";;eAWc,CAAC,GAAG,EAAE,MAAM,aAAa;WACzB,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM;uBACvB,CAAC,IAAI,EAAE;QAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAA;KAAC,KAAK,MAAM,GAAC,MAAM;gBACvE,GAAG,EAAE;YACL;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC;kBAChB,CAAC,GAAG,EAAE;QAAE,KAAK,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqZ8lX,CAAC;;;;;;;;wBAA2iB,CAAC;;;;;iCAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SArZpwc,CAAA;KAAE,KAAK,IAAI;;;;WAO3D,GAAG,GAAG,SAAS;cACf,OAAO,GAAG,SAAS;;AAmXjC;;;;GAIG;AACH,gBAAgB;AAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAoB2nX,CAAC;;;;;;;;oBAA2iB,CAAC;;;;;6BAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAHj0c"}
+{"version":3,"file":"use-model.d.ts","sourceRoot":"/src/","sources":["use-model.js"],"names":[],"mappings":";6BAUc,cAAc,iBAAiB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwd61d,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAtd7+jB,iBAAiB,GAAG;IAAC,EAAE,EAAE,MAAM,MAAM,GAAG,MAAM,CAAA;CAAC;;kCAE/C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;iCAC9D,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS;kCACrD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;4BAC3C;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAC;+BAC7B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;sCAC9D;IAAC,QAAQ,CAAC,EAAE,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAAC;yCAC/D;IAAC,QAAQ,EAAE,CAAC,IAAI,EAAE;QAAC,WAAW,EAAE,mBAAmB,GAAG,SAAS,CAAA;KAAC,KAAK,cAAc,CAAA;CAAC;sCACpF;IAAC,UAAU,EAAE,cAAc,CAAA;CAAC;sCAC5B;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC;;iBAG9D,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI;oBACjD,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI;;;aAIjD,OAAO;gBACP,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;gBACxB,kBAAkB,EAAE;mBACpB,OAAO;aACP,cAAc;uBACd,CAAC,IAAI,EAAE;QAAC,WAAW,EAAE,mBAAmB,GAAG,SAAS,CAAA;KAAC,KAAK,MAAM,GAAG,MAAM,GAAG,SAAS;YACrF,aAAa;gBACb,uBAAuB,GAAG,OAAO;oBACjC,gBAAgB;kBAChB,CAAC,GAAG,EAAE,uBAAuB,KAAK,IAAI;eACtC,OAAO;cACP,MAAM,EAAE,GAAG,MAAM;YACjB,eAAe;aACf,MAAM,EAAE,GAAG,MAAM;;8BAEjB,YAAY,GAAG,CAAC,CAAC,IAAI,EAAE,uBAAuB,KAAK,YAAY,CAAC;;cAGhE,eAAe;mBACf,cAAc,GAAG,0BAA0B;;;WAM3C,iBAAiB,GAAG,SAAS;cAC7B,OAAO,GAAG,SAAS;;6BAIpB;IACR,KAAK,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACrC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;CAC9B,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;AAwYhF;;;;;GAKG;AACH,yCAJW,cAAc,GAAG,0BAA0B,YAC3C,eAAe,GACb,cAAc,CAmB1B"}