orgnote-api 0.20.2 → 0.40.0

package/models/buffer-store.d.ts

@@ -0,0 +1,14 @@
+import type { ComputedRef, Ref } from 'vue';
+import { StoreDefinition } from './store.js';
+import { Buffer } from './buffer.js';
+export interface BufferStore {
+    buffers: Ref<Map<string, Buffer>>;
+    allBuffers: ComputedRef<Buffer[]>;
+    getOrCreateBuffer: (path: string) => Promise<Buffer>;
+    releaseBuffer: (path: string) => void;
+    closeBuffer: (path: string, force?: boolean) => Promise<boolean>;
+    getBufferByPath: (path: string) => Buffer | undefined;
+    saveAllBuffers: () => Promise<void>;
+    cleanup: () => void;
+}
+export type BufferStoreDefinition = StoreDefinition<BufferStore>;

package/models/buffer.d.ts

@@ -0,0 +1,24 @@
+import type { ValidationState } from './file-guard.js';
+type BufferError = string;
+export interface BufferMetadata<T = unknown> {
+    [key: string]: T;
+}
+export interface BufferGuard {
+    readonly: boolean;
+    reason?: string;
+    validation?: ValidationState;
+}
+export interface Buffer<T = unknown> {
+    path: string;
+    title: string;
+    content: string;
+    isSaving: boolean;
+    isLoading: boolean;
+    encryptionStatus?: boolean;
+    errors: BufferError[];
+    lastAccessed: Date;
+    referenceCount: number;
+    metadata: BufferMetadata<T>;
+    guard?: BufferGuard;
+}
+export {};

package/models/colors.d.ts

@@ -0,0 +1 @@
+export type Colors = '';

package/models/command.d.ts

@@ -1,6 +1,9 @@
+import { MaybeRefOrGetter } from 'vue';
+import { COMMAND_GROUPS } from "../constants/index.js";
 import { DefaultCommands } from './default-commands.js';
-import { COMMAND_GROUPS } from '../constants/command-groups.contant.js';
+import { OrgNoteApi } from "../api.js";
 export type CommandGroup = (typeof COMMAND_GROUPS)[number] | (string & Record<never, never>);
+export type CommandName = DefaultCommands | (string & {});
 export interface CommandHandlerParams<T = any> {
     event?: KeyboardEvent;
     data?: T;
@@ -8,22 +11,24 @@ export interface CommandHandlerParams<T = any> {
     [key: string]: unknown;
 }
 export interface CommandPreview {
-    description?: string;
-    command?: DefaultCommands | string;
-    title?: string | (() => string);
-    icon?: string | (() => string);
+    description?: MaybeRefOrGetter<string | undefined>;
+    command?: CommandName;
+    title?: MaybeRefOrGetter<string | undefined>;
+    icon?: MaybeRefOrGetter<string | undefined>;
 }
 export interface CommandMeta<T = any> extends Partial<CommandPreview> {
-    keySequence?: string | string[];
     group?: CommandGroup;
     allowOnInput?: boolean;
     interactive?: boolean;
     system?: boolean;
-    disabled?: () => boolean;
+    hide?: (api: OrgNoteApi) => boolean;
+    disabled?: (api: OrgNoteApi) => boolean;
+    isActive?: (api: OrgNoteApi) => boolean;
     context?: {
         [key: string]: T;
     };
 }
 export interface Command<T = any, R = unknown> extends CommandMeta<T> {
-    handler: (params?: CommandHandlerParams<T>) => R | Promise<R>;
+    handler: (api: OrgNoteApi, params: CommandHandlerParams<T>) => R | Promise<R>;
 }
+export type CommandCallback = <T = any>(meta: Command, data: T) => void;

package/models/commands-group-store.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { Command, CommandGroup } from './command.js';
+import { StoreDefinition } from './store.js';
+export interface CommandsGroupStore {
+    activateGroup: (group: CommandGroup) => void;
+    deactivateGroup: (group: CommandGroup) => void;
+    getCommandsByGroup: (group: CommandGroup) => Command[];
+    currentGroupsCommands: Ref<Command[]>;
+    currentGroups: Ref<CommandGroup[]>;
+}
+export type CommandsGroupStoreDefinition = StoreDefinition<CommandsGroupStore>;

package/models/commands-store.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+import { Command, CommandCallback } from './command.js';
+import { StoreDefinition } from './store.js';
+export type CommandUnsubscribFn = () => void;
+export interface CommandsStore {
+    add: (...newCommands: Command[]) => void;
+    remove: (...commandsToUnregister: Command[]) => void;
+    get: (name: string) => Command | undefined;
+    commands: Ref<Command[]>;
+    execute: (name: string, data?: unknown) => Promise<void>;
+    afterExecute: (commandNames: string | string[], callback: CommandCallback) => CommandUnsubscribFn;
+}
+export type CommandsStoreDefinition = StoreDefinition<CommandsStore>;

package/models/completion-store.d.ts

@@ -0,0 +1,14 @@
+import { ComputedRef } from 'vue';
+import { Completion, CompletionConfig } from './completion.js';
+import { StoreDefinition } from './store.js';
+export interface CompletionStore {
+    restore: () => void;
+    close: <TData = unknown>(data?: TData) => void;
+    closeAll: () => void;
+    open: <TItem, TReturn = void>(config: CompletionConfig<TItem>) => Promise<TReturn>;
+    activeCompletion: ComputedRef<Completion | undefined>;
+    nextCandidate: () => void;
+    previousCandidate: () => void;
+    search: (limit?: number, offset?: number) => void;
+}
+export type CompletionStoreDefinition = StoreDefinition<CompletionStore>;

package/models/completion.d.ts

@@ -1,22 +1,31 @@
+import { MaybeRefOrGetter } from 'vue';
 export interface CompletionCandidate<T = unknown> {
-    icon?: string | (() => string);
-    group?: string;
-    title?: string | (() => string);
-    description?: string | (() => string);
-    command: string;
+    icon?: MaybeRefOrGetter<string | undefined>;
+    group?: MaybeRefOrGetter<string | undefined>;
+    title?: MaybeRefOrGetter<string | undefined>;
+    description?: MaybeRefOrGetter<string | undefined>;
     data: T;
-    commandHandler?: (data: T) => void;
+    commandHandler: (data: T) => void;
 }
 export interface CompletionSearchResult<T = unknown> {
     total?: number;
     result: CompletionCandidate<T>[];
 }
 export type CandidateGetterFn<T = unknown> = (filter: string, limit?: number, offset?: number) => CompletionSearchResult<T> | Promise<CompletionSearchResult<T>>;
-export interface CompletionConfigs<T = unknown> {
+export interface CompletionConfig<T = unknown> {
     searchAutocompletions?: string[];
     itemsGetter: CandidateGetterFn<T>;
+    type?: 'input' | 'choice' | 'input-choice';
     placeholder?: string;
     itemHeight?: string;
     searchText?: string;
     onClicked?: (candidate: CompletionCandidate<T>) => void;
 }
+export interface Completion<T = any, TResult = any> extends CompletionConfig<T> {
+    level?: number;
+    candidates?: CompletionCandidate<T>[];
+    selectedCandidateIndex?: number;
+    total?: number;
+    searchQuery: string;
+    result: Promise<TResult>;
+}

package/models/config-store.d.ts

@@ -0,0 +1,9 @@
+import type { Ref, UnwrapNestedRefs } from 'vue';
+import { OrgNoteConfig } from './orgnote-config.js';
+import { StoreDefinition } from './store.js';
+export interface ConfigStore {
+    config: UnwrapNestedRefs<OrgNoteConfig>;
+    configErrors: Ref<string[]>;
+    sync: () => Promise<void>;
+}
+export type ConfigStoreDefinition = StoreDefinition<ConfigStore>;

package/models/confirmation-modal.d.ts

@@ -0,0 +1,11 @@
+export interface ConfirmationModalParams {
+    title?: string;
+    message?: string;
+    confirmText?: string;
+    cancelText?: string;
+}
+export interface ConfirmationModal {
+    confirm: (params?: ConfirmationModalParams) => Promise<boolean>;
+    resolveConfirmation: (data?: boolean) => void;
+}
+export type UseConfirmationModal = () => ConfirmationModal;

package/models/context-menu-store.d.ts

@@ -0,0 +1,10 @@
+import { MenuAction, MenuGroupParams } from './menu-action.js';
+import { StoreDefinition } from './store.js';
+export interface ContextMenuStore {
+    registerGroup: (group: string) => void;
+    updateContextGroup: (group: string, params: MenuGroupParams) => void;
+    addContextMenuAction: (group: string, action: MenuAction) => void;
+    removeContextMenuAction: (group: string, action: MenuAction) => void;
+    getContextMenuActions: (group: string) => MenuAction[];
+}
+export type ContextMenuStoreDefinition = StoreDefinition<ContextMenuStore>;

package/models/cron-store.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+import { StoreDefinition } from './store.js';
+import { CronTask, CronTaskConfig, PeriodicTaskStatus } from './cron-task.js';
+export type SchedulerStatus = 'running' | 'stopped' | 'error';
+export interface CronStore {
+    tasks: Ref<Record<string, CronTask>>;
+    status: Ref<SchedulerStatus>;
+    init: () => Promise<void>;
+    cleanup: () => Promise<void>;
+    get: (id: string) => CronTask | undefined;
+    pause: (id: string) => Promise<void>;
+    resume: (id: string) => Promise<void>;
+    stop: (id: string) => Promise<void>;
+    runImmediately: (id: string) => Promise<void>;
+    pauseAll: () => Promise<void>;
+    resumeAll: () => Promise<void>;
+    getByStatus: (status: PeriodicTaskStatus) => CronTask[];
+    register: (task: CronTaskConfig) => Promise<CronTask>;
+    unregister: (id: string) => Promise<void>;
+}
+export type CronStoreDefinition = StoreDefinition<CronStore>;

package/models/cron-task.d.ts

@@ -0,0 +1,30 @@
+import { OrgNoteApi } from "../api.js";
+import { Platform } from './platform.js';
+export type PeriodicTaskStatus = 'active' | 'paused' | 'stopped';
+export type PeriodicTaskRunResult = 'success' | 'error' | 'skipped';
+export interface BaseCronTaskConfig {
+    id: string;
+    handler: (api: OrgNoteApi) => Promise<void> | void;
+    runImmediately?: boolean;
+    catchUpOnResume?: boolean;
+    /** Default 1 **/
+    maxCatchUpRuns?: number;
+    /** Default true **/
+    preventOverrun?: boolean;
+    /** Default 30000 ms per task, when maximum time is exceeded, the task is considered failed **/
+    timeout?: number;
+    runWhen?: (api: OrgNoteApi) => Promise<boolean>;
+    platforms?: Platform[];
+}
+export interface IntervalCronTask extends BaseCronTaskConfig {
+    interval: number;
+}
+export interface CronExpressionTask extends BaseCronTaskConfig {
+    cron: string;
+}
+export type CronTaskConfig = IntervalCronTask | CronExpressionTask;
+export type CronTask = CronTaskConfig & {
+    status: PeriodicTaskStatus;
+    lastRun?: number;
+    nextRun?: number;
+};

package/models/css-utils.d.ts

@@ -0,0 +1,17 @@
+import { ThemeVariable } from './theme-variables.js';
+export type ThemeColors = {
+    [key in ThemeVariable]?: string;
+};
+export type GetCssVar = (varName: string) => string | undefined;
+export type GetCssTheme = (variableNames: string[]) => {
+    [key in ThemeVariable]?: string;
+};
+export type GetNumericCssVar = (varName: string) => number | undefined;
+export type GetCssProperty = (element: Element, propertyName: string) => string | undefined;
+export type GetCssNumericProperty = (element: Element, propertyName: string) => number | undefined;
+export type ApplyCSSVariables<T extends string> = (variables: {
+    [key in T]?: string | number;
+}) => void;
+export type ResetCSSVariables<T extends string> = (variables: T[]) => void;
+export type ApplyScopedStyles = (scopeName: string, styles: string) => void;
+export type RemoveScopedStyles = (scopeName: string) => void;

package/models/default-commands.d.ts

@@ -2,6 +2,7 @@ export declare enum DefaultCommands {
     REPORT_BUG = "report bug",
     OPEN_DEBUG_INFO = "open debug info",
     SHOW_LOGS = "show logs",
+    CLEAR_LOGS = "clear logs",
     TOGGLE_SIDEBAR = "toggle sidebar",
     TOGGLE_FILE_MANAGER = "toggle file manager",
     CREATE_NOTE = "create note",
@@ -15,19 +16,67 @@ export declare enum DefaultCommands {
     EXECUTE_CANDIDATE = "execute candidate",
     SETTINGS = "settings",
     RESET_THEME = "reset theme",
-    TOGGLE_DARK_MODE = "toggle dark mode",
+    SELECT_THEME_MODE = "select theme mode",
     TOGGLE_DEBUG_MODE = "toggle debug mode",
     SELECT_THEME = "select theme",
+    SYSTEM_SETTINGS = "system settings",
+    LANGUAGE_SETTINGS = "language settings",
+    INTERFACE_SETTINGS = "interface settings",
+    SYNCHRONISATION_SETTINGS = "synchronisation settings",
+    SUBSCRIPTION_SETTINGS = "subscription settings",
+    KEYBINDINGS_SETTINGS = "keybindings settings",
+    DEVELOPER_SETTINGS = "developer settings",
+    EXTENSIONS_SETTINGS = "extensions",
+    ENCRYPTION_SETTINGS = "encryption settings",
+    API_SETTINGS = "api settings",
+    AUTHENTICATION_SETTINGS = "authentication settings",
+    SOURCE_CODE = "show source code",
+    READ_WIKI = "read wiki",
+    SPONSOR = "sponsor",
+    DELETE_ALL_DATA = "delete all data",
+    DELETE_ALL_NOTES = "delete all notes",
+    DELETE_ACCOUNT = "delete account",
+    STORAGE_SETTINGS = "storage settings",
     OPEN_MY_NOTES = "my notes",
     OPEN_DASHBOARD = "dashboard",
     OPEN_PUBLIC_NOTE_LIST = "public note list",
     OPEN_NOTE_EDITOR = "edit mode",
     OPEN_NOTE_VIEWER = "view mode",
     OPEN_GRAPH = "graph",
-    OPEN_EXTENSIONS = "extensions",
     SELECT_FILE_PATH = "select file path",
     PICK_SYNC_DIR = "pick sync dir",
     SYNC_FILES = "sync files",
+    RELOAD_FILES = "reload files",
     ENCRYPT_NOTE = "encrypt note",
-    DECRYPT_NOTE = "decrypt note"
+    DECRYPT_NOTE = "decrypt note",
+    MAXIMIZE_FILE_MANAGER = "maximize file manager",
+    CREATE_FOLDER = "create folder",
+    CREATE_FILE = "create file",
+    RENAME_FILE = "rename file",
+    DELETE_FILE = "delete file",
+    CONFIRM_FILE_DELETION = "are you sure you want to delete file?",
+    NEW_FILE_PATH = "new file path",
+    OPEN_NOTE = "open note",
+    OPEN_CODE_EDITOR = "open code editor",
+    TABS = "show tabs",
+    SHOW_TAB_SWITCHER = "show tab switcher",
+    CLOSE_TAB = "close tab",
+    NEW_TAB = "new tab",
+    RESIZE_PANE_LEFT = "resize pane left",
+    RESIZE_PANE_RIGHT = "resize pane right",
+    RESIZE_PANE_UP = "resize pane up",
+    RESIZE_PANE_DOWN = "resize pane down",
+    CLOSE_MODAL = "close modal",
+    OPEN_QUEUE_MANAGER = "open queue manager",
+    RESTART_QUEUE = "restart queue",
+    STOP_QUEUE = "stop queue",
+    CLEAR_QUEUE = "clear queue",
+    OPEN_CRON = "open cron manager",
+    CLEAR_OLD_QUEUE_TASKS = "clear old queue tasks",
+    COPY_COMMAND_URL = "copy command url",
+    IMPORT_EXTENSION = "import extension",
+    OPEN_EXTENSIONS_MANAGER = "open extensions manager",
+    LOGIN = "login",
+    LOGOUT = "logout",
+    REMOVE_ACCOUNT = "remove account"
 }

package/models/default-commands.js

@@ -9,6 +9,7 @@ export var DefaultCommands;
     DefaultCommands["REPORT_BUG"] = "report bug";
     DefaultCommands["OPEN_DEBUG_INFO"] = "open debug info";
     DefaultCommands["SHOW_LOGS"] = "show logs";
+    DefaultCommands["CLEAR_LOGS"] = "clear logs";
     DefaultCommands["TOGGLE_SIDEBAR"] = "toggle sidebar";
     DefaultCommands["TOGGLE_FILE_MANAGER"] = "toggle file manager";
     DefaultCommands["CREATE_NOTE"] = "create note";
@@ -24,9 +25,27 @@ export var DefaultCommands;
     // Settings
     DefaultCommands["SETTINGS"] = "settings";
     DefaultCommands["RESET_THEME"] = "reset theme";
-    DefaultCommands["TOGGLE_DARK_MODE"] = "toggle dark mode";
+    DefaultCommands["SELECT_THEME_MODE"] = "select theme mode";
     DefaultCommands["TOGGLE_DEBUG_MODE"] = "toggle debug mode";
     DefaultCommands["SELECT_THEME"] = "select theme";
+    DefaultCommands["SYSTEM_SETTINGS"] = "system settings";
+    DefaultCommands["LANGUAGE_SETTINGS"] = "language settings";
+    DefaultCommands["INTERFACE_SETTINGS"] = "interface settings";
+    DefaultCommands["SYNCHRONISATION_SETTINGS"] = "synchronisation settings";
+    DefaultCommands["SUBSCRIPTION_SETTINGS"] = "subscription settings";
+    DefaultCommands["KEYBINDINGS_SETTINGS"] = "keybindings settings";
+    DefaultCommands["DEVELOPER_SETTINGS"] = "developer settings";
+    DefaultCommands["EXTENSIONS_SETTINGS"] = "extensions";
+    DefaultCommands["ENCRYPTION_SETTINGS"] = "encryption settings";
+    DefaultCommands["API_SETTINGS"] = "api settings";
+    DefaultCommands["AUTHENTICATION_SETTINGS"] = "authentication settings";
+    DefaultCommands["SOURCE_CODE"] = "show source code";
+    DefaultCommands["READ_WIKI"] = "read wiki";
+    DefaultCommands["SPONSOR"] = "sponsor";
+    DefaultCommands["DELETE_ALL_DATA"] = "delete all data";
+    DefaultCommands["DELETE_ALL_NOTES"] = "delete all notes";
+    DefaultCommands["DELETE_ACCOUNT"] = "delete account";
+    DefaultCommands["STORAGE_SETTINGS"] = "storage settings";
     // Routing
     DefaultCommands["OPEN_MY_NOTES"] = "my notes";
     DefaultCommands["OPEN_DASHBOARD"] = "dashboard";
@@ -34,12 +53,50 @@ export var DefaultCommands;
     DefaultCommands["OPEN_NOTE_EDITOR"] = "edit mode";
     DefaultCommands["OPEN_NOTE_VIEWER"] = "view mode";
     DefaultCommands["OPEN_GRAPH"] = "graph";
-    DefaultCommands["OPEN_EXTENSIONS"] = "extensions";
     // Native mobile specific
     DefaultCommands["SELECT_FILE_PATH"] = "select file path";
     DefaultCommands["PICK_SYNC_DIR"] = "pick sync dir";
     // File management
     DefaultCommands["SYNC_FILES"] = "sync files";
+    DefaultCommands["RELOAD_FILES"] = "reload files";
     DefaultCommands["ENCRYPT_NOTE"] = "encrypt note";
     DefaultCommands["DECRYPT_NOTE"] = "decrypt note";
+    // File manager
+    DefaultCommands["MAXIMIZE_FILE_MANAGER"] = "maximize file manager";
+    DefaultCommands["CREATE_FOLDER"] = "create folder";
+    DefaultCommands["CREATE_FILE"] = "create file";
+    DefaultCommands["RENAME_FILE"] = "rename file";
+    DefaultCommands["DELETE_FILE"] = "delete file";
+    DefaultCommands["CONFIRM_FILE_DELETION"] = "are you sure you want to delete file?";
+    DefaultCommands["NEW_FILE_PATH"] = "new file path";
+    // Notes commands
+    DefaultCommands["OPEN_NOTE"] = "open note";
+    DefaultCommands["OPEN_CODE_EDITOR"] = "open code editor";
+    // Windows & buffers
+    DefaultCommands["TABS"] = "show tabs";
+    DefaultCommands["SHOW_TAB_SWITCHER"] = "show tab switcher";
+    DefaultCommands["CLOSE_TAB"] = "close tab";
+    DefaultCommands["NEW_TAB"] = "new tab";
+    // Pane resize
+    DefaultCommands["RESIZE_PANE_LEFT"] = "resize pane left";
+    DefaultCommands["RESIZE_PANE_RIGHT"] = "resize pane right";
+    DefaultCommands["RESIZE_PANE_UP"] = "resize pane up";
+    DefaultCommands["RESIZE_PANE_DOWN"] = "resize pane down";
+    // Modal
+    DefaultCommands["CLOSE_MODAL"] = "close modal";
+    // Developer settings
+    DefaultCommands["OPEN_QUEUE_MANAGER"] = "open queue manager";
+    DefaultCommands["RESTART_QUEUE"] = "restart queue";
+    DefaultCommands["STOP_QUEUE"] = "stop queue";
+    DefaultCommands["CLEAR_QUEUE"] = "clear queue";
+    DefaultCommands["OPEN_CRON"] = "open cron manager";
+    DefaultCommands["CLEAR_OLD_QUEUE_TASKS"] = "clear old queue tasks";
+    DefaultCommands["COPY_COMMAND_URL"] = "copy command url";
+    // Extensions
+    DefaultCommands["IMPORT_EXTENSION"] = "import extension";
+    DefaultCommands["OPEN_EXTENSIONS_MANAGER"] = "open extensions manager";
+    // Auth
+    DefaultCommands["LOGIN"] = "login";
+    DefaultCommands["LOGOUT"] = "logout";
+    DefaultCommands["REMOVE_ACCOUNT"] = "remove account";
 })(DefaultCommands || (DefaultCommands = {}));

package/models/encryption-store.d.ts

@@ -0,0 +1,10 @@
+import { BaseOrgNoteEncryption, OrgNoteEncryption, BaseOrgNoteDecryption } from './encryption.js';
+import { NoteInfo } from './note.js';
+import { StoreDefinition } from './store.js';
+export interface EncryptionStore {
+    encrypt: (text: string, format?: BaseOrgNoteEncryption['format'], encryptionConfig?: OrgNoteEncryption) => Promise<string>;
+    decrypt: (content: string | Uint8Array, format?: BaseOrgNoteDecryption['format'], encryptionConfig?: OrgNoteEncryption) => Promise<string>;
+    encryptNote: (noteInfo: NoteInfo, noteText: string) => Promise<[NoteInfo, string]>;
+    decryptNote: (noteInfo: NoteInfo, noteText: string) => Promise<[NoteInfo, string | Uint8Array]>;
+}
+export type EncryptionStoreDefinition = StoreDefinition<EncryptionStore>;

package/models/encryption-store.js

@@ -0,0 +1 @@
+export {};

package/models/encryption.d.ts

@@ -1,4 +1,10 @@
-import type { ModelsPublicNoteEncryptionTypeEnum } from '../remote-api/index.js';
+import { InferOutput } from 'valibot';
+export declare const EncryptionType: {
+    readonly GpgKeys: "gpgKeys";
+    readonly GpgPassword: "gpgPassword";
+    readonly Disabled: "disabled";
+};
+export type EncryptionType = (typeof EncryptionType)[keyof typeof EncryptionType];
 export type EcnryptionFormat = 'binary' | 'armored';
 export interface BaseOrgNoteEncryption {
     format?: 'binary' | 'armored';
@@ -6,20 +12,56 @@ export interface BaseOrgNoteEncryption {
 export interface BaseOrgNoteDecryption {
     format?: 'utf8' | 'binary';
 }
-export interface OrgNoteGpgEncryption {
-    type: typeof ModelsPublicNoteEncryptionTypeEnum.GpgKeys;
+declare const OrgNoteGpgEncryptionSchema: import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"gpgKeys", undefined>;
+    readonly privateKey: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MetadataAction<string, {
+        readonly textarea: true;
+        readonly upload: true;
+    }>]>;
+    readonly publicKey: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, import("valibot").MetadataAction<string, {
+        readonly textarea: true;
+        readonly upload: true;
+    }>]>;
+    readonly privateKeyPassphrase: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+declare const OrgNotePasswordEncryptionSchema: import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"gpgPassword", undefined>;
+    readonly password: import("valibot").StringSchema<undefined>;
+}, undefined>;
+export declare const OrgNoteEncryptionSchema: import("valibot").IntersectSchema<[import("valibot").ObjectSchema<{
+    readonly encryptFilesByDefault: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+}, undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"gpgKeys", undefined>;
+    readonly privateKey: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MetadataAction<string, {
+        readonly textarea: true;
+        readonly upload: true;
+    }>]>;
+    readonly publicKey: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, import("valibot").MetadataAction<string, {
+        readonly textarea: true;
+        readonly upload: true;
+    }>]>;
+    readonly privateKeyPassphrase: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>, import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"gpgPassword", undefined>;
+    readonly password: import("valibot").StringSchema<undefined>;
+}, undefined>, import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"disabled", undefined>;
+}, undefined>], undefined>, import("valibot").MetadataAction<{
+    type: "gpgKeys";
     privateKey: string;
     publicKey?: string;
     privateKeyPassphrase?: string;
-}
-export interface OrgNotePasswordEncryption {
-    type: typeof ModelsPublicNoteEncryptionTypeEnum.GpgPassword;
+} | {
+    type: "gpgPassword";
     password: string;
-}
-export interface OrgNoteDisabledEncryption {
-    type: typeof ModelsPublicNoteEncryptionTypeEnum.Disabled;
-}
-export type OrgNoteEncryption = OrgNoteGpgEncryption | OrgNotePasswordEncryption | OrgNoteDisabledEncryption;
+} | {
+    type: "disabled";
+}, {
+    readonly conditionalKey: "type";
+}>]>], undefined>;
+export type OrgNoteGpgEncryption = InferOutput<typeof OrgNoteGpgEncryptionSchema>;
+export type OrgNotePasswordEncryption = InferOutput<typeof OrgNotePasswordEncryptionSchema>;
+export type OrgNoteEncryption = InferOutput<typeof OrgNoteEncryptionSchema>;
 export type EncryptionData = {
     content: string;
 };
@@ -29,3 +71,4 @@ export type DecriptionData = {
 };
 export type WithDecryptionContent<T extends OrgNoteEncryption = OrgNoteEncryption> = T & DecriptionData & BaseOrgNoteDecryption;
 export type WithNoteDecryptionContent<T extends OrgNoteEncryption = OrgNoteEncryption> = T & DecriptionData;
+export {};

package/models/encryption.js

@@ -1 +1,28 @@
-export {};
+import { boolean, metadata } from 'valibot';
+import { object, string, union, optional, literal, intersect, pipe, } from 'valibot';
+export const EncryptionType = {
+    GpgKeys: 'gpgKeys',
+    GpgPassword: 'gpgPassword',
+    Disabled: 'disabled',
+};
+const OrgNoteGpgEncryptionSchema = object({
+    type: literal(EncryptionType.GpgKeys),
+    privateKey: pipe(string(), metadata({ textarea: true, upload: true })),
+    publicKey: pipe(optional(string()), metadata({ textarea: true, upload: true })),
+    privateKeyPassphrase: optional(string()),
+});
+const OrgNotePasswordEncryptionSchema = object({
+    type: literal(EncryptionType.GpgPassword),
+    password: string(),
+});
+const OrgNoteDisabledEncryptionSchema = object({
+    type: literal(EncryptionType.Disabled),
+});
+export const OrgNoteEncryptionSchema = intersect([
+    object({ encryptFilesByDefault: optional(boolean()) }),
+    pipe(union([
+        OrgNoteGpgEncryptionSchema,
+        OrgNotePasswordEncryptionSchema,
+        OrgNoteDisabledEncryptionSchema,
+    ]), metadata({ conditionalKey: 'type' })),
+]);

package/models/extension-registry-store.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from 'vue';
+import type { ExtensionManifest } from './extension.js';
+import type { StoreDefinition } from './store.js';
+export interface ExtensionRegistryStore {
+    availableExtensions: Ref<ExtensionManifest[]>;
+    loading: Ref<boolean>;
+    refresh: () => Promise<void>;
+}
+export type ExtensionRegistryStoreDefinition = StoreDefinition<ExtensionRegistryStore>;

package/models/extension-registry-store.js

@@ -0,0 +1 @@
+export {};

package/models/extension-store.d.ts

@@ -0,0 +1,18 @@
+import type { Ref } from 'vue';
+import { ExtensionMeta, ExtensionSource, ExtensionSourceInfo } from './extension.js';
+import { StoreDefinition } from './store.js';
+export interface ExtensionStore {
+    ready: Ref<boolean>;
+    extensions: Ref<ExtensionMeta[]>;
+    sync: () => Promise<void>;
+    enableExtension: (extensionName: string) => Promise<void>;
+    disableExtension: (extensionName: string) => Promise<void>;
+    enableSafeMode: () => Promise<void>;
+    disableSafeMode: () => Promise<void>;
+    isExtensionExist: (extensionName: string) => boolean;
+    installExtension: (source: ExtensionSourceInfo) => Promise<void>;
+    addExtension: (meta: ExtensionMeta, source: ExtensionSource) => Promise<void>;
+    importExtension: (file: File) => Promise<void>;
+    deleteExtension: (extensionName: string) => Promise<void>;
+}
+export type ExtensionStoreDefinition = StoreDefinition<ExtensionStore>;

package/models/extension-store.js

@@ -0,0 +1 @@
+export {};