@kaspernj/api-maker 1.0.2159 → 1.0.2161

package/build/devise.d.ts

@@ -1,68 +1,667 @@
 /** ApiMakerDevise. */
 export default class ApiMakerDevise {
-    /** callSignOutEvent. */
-    static callSignOutEvent(args: any): void;
+    /**
+     * Emits the shared sign-out event payload for one scope.
+     * @param {DeviseScopeArgs} args
+     * @returns {void}
+     */
+    static callSignOutEvent(args: DeviseScopeArgs): void;
     /** @returns {ApiMakerDevise} */
     static current(): ApiMakerDevise;
-    /** events. */
-    static events(): import("eventemitter3").EventEmitter<string | symbol, any>;
-    /** addUserScope. */
-    static addUserScope(scope: any, args?: {}): void;
-    /** getScope. */
-    static getScope(scope: any): any;
+    /**
+     * Returns the shared event emitter used for Devise lifecycle events.
+     * @returns {typeof events}
+     */
+    static events(): typeof events;
+    /**
+     * Registers one Devise scope and its helper accessors.
+     * @param {string} scope
+     * @param {DeviseScopeArgs} args
+     */
+    static addUserScope(scope: string, args?: DeviseScopeArgs): void;
+    /**
+     * Returns the registered scope helper for one scope name.
+     * @param {string} scope
+     * @returns {DeviseScope}
+     */
+    static getScope(scope: string): DeviseScope;
     /** @returns {string[]} */
     static registeredScopes(): string[];
-    static signIn(username: any, password: any, args?: {}): Promise<{
-        model: any;
-        response: any;
+    /**
+     * Signs in one scope over HTTP and refreshes websocket auth state.
+     * @param {string} username
+     * @param {string} password
+     * @param {DeviseScopeArgs} args
+     * @returns {Promise<{model: import("./base-model.js").default | undefined, response: DeviseSignInResponse}>}
+     */
+    static signIn(username: string, password: string, args?: DeviseScopeArgs): Promise<{
+        model: {
+            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;
+        } | undefined;
+        response: DeviseSignInResponse;
     }>;
     /**
      * Synchronizes the current backend auth state into real HTTP response cookies.
      *
-     * @param {Record<string, any>} [args]
-     * @returns {Promise<any>}
+     * @param {DeviseScopeArgs} [args]
+     * @returns {Promise<DeviseSessionStatusResult>}
+     */
+    static persistSession(args?: DeviseScopeArgs): Promise<DeviseSessionStatusResult>;
+    /**
+     * Updates the locally cached current model for one scope.
+     * @param {DeviseCurrentScope} model
+     * @param {DeviseScopeArgs} args
+     */
+    static updateSession(model: DeviseCurrentScope, args?: DeviseScopeArgs): void;
+    /**
+     * Marks one scope as signed out in the local current-model cache.
+     * @param {DeviseScopeArgs} args
      */
-    static persistSession(args?: Record<string, any>): Promise<any>;
-    /** updateSession. */
-    static updateSession(model: any, args?: {}): void;
-    /** setSignedOut. */
-    static setSignedOut(args: any): void;
-    static signOut(args?: {}): Promise<any>;
+    static setSignedOut(args: DeviseScopeArgs): void;
+    /**
+     * Signs out one scope over HTTP and refreshes websocket auth state.
+     * @param {DeviseScopeArgs} args
+     * @returns {Promise<DeviseSessionStatusResult>}
+     */
+    static signOut(args?: DeviseScopeArgs): Promise<DeviseSessionStatusResult>;
     /**
      * Applies the latest HTTP session status locally, then refreshes the
      * existing websocket connection so ApiMaker commands use the same auth.
      *
-     * @param {Record<string, any>} args
-     * @returns {Promise<Record<string, any>>}
+     * @param {SyncSessionArgs} args
+     * @returns {Promise<DeviseSessionStatusResult>}
      */
-    static syncSessionStatusAndRefreshWebsocket(args: Record<string, any>): Promise<Record<string, any>>;
+    static syncSessionStatusAndRefreshWebsocket(args: SyncSessionArgs): Promise<DeviseSessionStatusResult>;
     /**
-     * @param {Record<string, any>} httpResponse
-     * @returns {Promise<Record<string, any>>}
+     * Updates local session status from one HTTP response payload.
+     * @param {DeviseSessionStatusResult} httpResponse
+     * @returns {Promise<DeviseSessionStatusResult>}
      */
-    static syncSessionStatusFromHttpResponse(httpResponse: Record<string, any>): Promise<Record<string, any>>;
+    static syncSessionStatusFromHttpResponse(httpResponse: DeviseSessionStatusResult): Promise<DeviseSessionStatusResult>;
     /**
      * Refreshes ApiMaker auth inside the existing websocket connection.
      *
-     * @param {Record<string, any>} args
-     * @returns {Promise<any>}
+     * @param {DeviseScopeArgs & {shadowSessionToken?: string}} args
+     * @returns {Promise<DeviseSessionStatusResult>}
      */
-    static refreshWebsocketSession(args: Record<string, any>): Promise<any>;
+    static refreshWebsocketSession(args: DeviseScopeArgs & {
+        shadowSessionToken?: string;
+    }): Promise<DeviseSessionStatusResult>;
     /**
      * Refreshes auth on the existing subscriptions channel pools.
      *
-     * @param {Record<string, any>} args
+     * @param {DeviseScopeArgs & {shadowSessionToken?: string}} args
      * @returns {Promise<void>}
      */
-    static refreshSubscriptionAuthentication(args: Record<string, any>): Promise<void>;
-    /** hasCurrentScope. */
-    hasCurrentScope(scope: any): boolean;
-    currents: {};
-    /** getCurrentScope. */
-    getCurrentScope(scope: any): any;
-    /** hasGlobalCurrentScope. */
-    hasGlobalCurrentScope(scope: any): boolean;
-    /** loadCurrentScope. */
-    loadCurrentScope(scope: any): any;
+    static refreshSubscriptionAuthentication(args: DeviseScopeArgs & {
+        shadowSessionToken?: string;
+    }): Promise<void>;
+    /**
+     * Returns whether the current scope cache has been initialized locally.
+     * @param {string} scope
+     * @returns {boolean}
+     */
+    hasCurrentScope(scope: string): boolean;
+    currents: Record<string, {
+        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;
+    }>;
+    /**
+     * Returns the current model cached for one scope.
+     * @param {string} scope
+     * @returns {DeviseCurrentScope}
+     */
+    getCurrentScope(scope: string): DeviseCurrentScope;
+    /**
+     * Returns whether the server rendered current-scope payload for one scope.
+     * @param {string} scope
+     * @returns {boolean}
+     */
+    hasGlobalCurrentScope(scope: string): boolean;
+    /**
+     * Hydrates the current scope model from the server rendered payload.
+     * @param {string} scope
+     * @returns {DeviseCurrentScope}
+     */
+    loadCurrentScope(scope: string): DeviseCurrentScope;
+}
+export type ApiMakerDeviseShared = {
+    scopes?: Record<string, boolean>;
+    currentApiMakerDevise?: ApiMakerDevise;
+};
+export type DeviseSessionStatusScope = {
+    signed_in: boolean;
+};
+export type DeviseSessionStatusResult = {
+    csrf_token?: string;
+    scopes: Record<string, DeviseSessionStatusScope>;
+    shadow_session_token?: string;
+    session_status?: DeviseSessionStatusResult;
+};
+export type DeviseScopeArgs = {
+    rememberMe?: boolean;
+    scope?: string;
+    signedIn?: boolean;
+    skipSignInEvent?: boolean;
+};
+export type DeviseSignInResponse = DeviseSessionStatusResult & {
+    model?: {
+        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;
+    } | {
+        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 SyncSessionArgs = {
+    httpResponse: DeviseSessionStatusResult;
+    scope: string;
+    websocketArgs: DeviseScopeArgs;
+};
+export type DeviseCurrentScope = {
+    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;
+} | null;
+import events from "./events.js";
+/** DeviseScope. */
+declare class DeviseScope {
+    /**
+     * Constructor.
+     * @param {string} scope
+     * @param {DeviseScopeArgs} args
+     */
+    constructor(scope: string, args: DeviseScopeArgs);
+    args: DeviseScopeArgs;
+    context: import("react").Context<any>;
+    scope: string;
+    /** @returns {import("react").Context<DeviseCurrentScope | undefined>} */
+    getContext: () => import("react").Context<DeviseCurrentScope | undefined>;
 }
+export {};
 //# sourceMappingURL=devise.d.ts.map