@powerhousedao/common 1.1.0

package/dist/cjs/utils/lazy-with-preload.js

@@ -0,0 +1 @@
+"use strict";const v=require("react");var e={},d;function P(){if(d)return e;d=1,Object.defineProperty(e,"__esModule",{value:!0}),e.lazyWithPreload=void 0;var r=v;function a(f){var o=(0,r.lazy)(f),t,n,l=(0,r.forwardRef)(function(u,c){var s=(0,r.useRef)(t??o);return(0,r.createElement)(s.current,Object.assign(c?{ref:c}:{},u))}),i=l;return i.preload=function(){return n||(n=f().then(function(u){return t=u.default,t})),n},i}return e.lazyWithPreload=a,e.default=a,e}var y=P();exports.P=y;

package/dist/document-drive.d.ts

@@ -0,0 +1,2 @@
+export * from './document-models/document-drive/index'
+export {}

package/dist/document-models/document-drive/gen/actions.d.ts

@@ -0,0 +1,5 @@
+import { DocumentDriveNodeAction } from './node/actions';
+import { DocumentDriveDriveAction } from './drive/actions';
+export * from './node/actions';
+export * from './drive/actions';
+export type DocumentDriveAction = DocumentDriveNodeAction | DocumentDriveDriveAction;

package/dist/document-models/document-drive/gen/creators.d.ts

@@ -0,0 +1,2 @@
+export * from './node/creators';
+export * from './drive/creators';

package/dist/document-models/document-drive/gen/document-model.d.ts

@@ -0,0 +1,2 @@
+import { DocumentModelState } from 'document-model/document-model';
+export declare const documentModel: DocumentModelState;

package/dist/document-models/document-drive/gen/drive/actions.d.ts

@@ -0,0 +1,11 @@
+import { Action } from 'document-model/document';
+import { SetDriveNameInput, SetDriveIconInput, SetSharingTypeInput, SetAvailableOfflineInput, AddListenerInput, RemoveListenerInput, AddTriggerInput, RemoveTriggerInput } from '../types';
+export type SetDriveNameAction = Action<"SET_DRIVE_NAME", SetDriveNameInput, "global">;
+export type SetDriveIconAction = Action<"SET_DRIVE_ICON", SetDriveIconInput, "global">;
+export type SetSharingTypeAction = Action<"SET_SHARING_TYPE", SetSharingTypeInput, "local">;
+export type SetAvailableOfflineAction = Action<"SET_AVAILABLE_OFFLINE", SetAvailableOfflineInput, "local">;
+export type AddListenerAction = Action<"ADD_LISTENER", AddListenerInput, "local">;
+export type RemoveListenerAction = Action<"REMOVE_LISTENER", RemoveListenerInput, "local">;
+export type AddTriggerAction = Action<"ADD_TRIGGER", AddTriggerInput, "local">;
+export type RemoveTriggerAction = Action<"REMOVE_TRIGGER", RemoveTriggerInput, "local">;
+export type DocumentDriveDriveAction = SetDriveNameAction | SetDriveIconAction | SetSharingTypeAction | SetAvailableOfflineAction | AddListenerAction | RemoveListenerAction | AddTriggerAction | RemoveTriggerAction;

package/dist/document-models/document-drive/gen/drive/creators.d.ts

@@ -0,0 +1,10 @@
+import { SetDriveNameInput, SetDriveIconInput, SetSharingTypeInput, SetAvailableOfflineInput, AddListenerInput, RemoveListenerInput, AddTriggerInput, RemoveTriggerInput } from '../types';
+import { SetDriveNameAction, SetDriveIconAction, SetSharingTypeAction, SetAvailableOfflineAction, AddListenerAction, RemoveListenerAction, AddTriggerAction, RemoveTriggerAction } from './actions';
+export declare const setDriveName: (input: SetDriveNameInput) => SetDriveNameAction;
+export declare const setDriveIcon: (input: SetDriveIconInput) => SetDriveIconAction;
+export declare const setSharingType: (input: SetSharingTypeInput) => SetSharingTypeAction;
+export declare const setAvailableOffline: (input: SetAvailableOfflineInput) => SetAvailableOfflineAction;
+export declare const addListener: (input: AddListenerInput) => AddListenerAction;
+export declare const removeListener: (input: RemoveListenerInput) => RemoveListenerAction;
+export declare const addTrigger: (input: AddTriggerInput) => AddTriggerAction;
+export declare const removeTrigger: (input: RemoveTriggerInput) => RemoveTriggerAction;

package/dist/document-models/document-drive/gen/drive/error.d.ts

@@ -0,0 +1 @@
+export declare const errors: {};

package/dist/document-models/document-drive/gen/drive/object.d.ts

@@ -0,0 +1,13 @@
+import { BaseDocument } from 'document-model/document';
+import { SetDriveNameInput, SetDriveIconInput, SetSharingTypeInput, SetAvailableOfflineInput, AddListenerInput, RemoveListenerInput, AddTriggerInput, RemoveTriggerInput, DocumentDriveState, DocumentDriveLocalState } from '../types';
+import { DocumentDriveAction } from '../actions';
+export default class DocumentDrive_Drive extends BaseDocument<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState> {
+    setDriveName(input: SetDriveNameInput): this;
+    setDriveIcon(input: SetDriveIconInput): this;
+    setSharingType(input: SetSharingTypeInput): this;
+    setAvailableOffline(input: SetAvailableOfflineInput): this;
+    addListener(input: AddListenerInput): this;
+    removeListener(input: RemoveListenerInput): this;
+    addTrigger(input: AddTriggerInput): this;
+    removeTrigger(input: RemoveTriggerInput): this;
+}

package/dist/document-models/document-drive/gen/drive/operations.d.ts

@@ -0,0 +1,13 @@
+import { SignalDispatch } from 'document-model/document';
+import { SetDriveNameAction, SetDriveIconAction, SetSharingTypeAction, SetAvailableOfflineAction, AddListenerAction, RemoveListenerAction, AddTriggerAction, RemoveTriggerAction } from './actions';
+import { DocumentDriveState, DocumentDriveLocalState } from '../types';
+export interface DocumentDriveDriveOperations {
+    setDriveNameOperation: (state: DocumentDriveState, action: SetDriveNameAction, dispatch?: SignalDispatch) => void;
+    setDriveIconOperation: (state: DocumentDriveState, action: SetDriveIconAction, dispatch?: SignalDispatch) => void;
+    setSharingTypeOperation: (state: DocumentDriveLocalState, action: SetSharingTypeAction, dispatch?: SignalDispatch) => void;
+    setAvailableOfflineOperation: (state: DocumentDriveLocalState, action: SetAvailableOfflineAction, dispatch?: SignalDispatch) => void;
+    addListenerOperation: (state: DocumentDriveLocalState, action: AddListenerAction, dispatch?: SignalDispatch) => void;
+    removeListenerOperation: (state: DocumentDriveLocalState, action: RemoveListenerAction, dispatch?: SignalDispatch) => void;
+    addTriggerOperation: (state: DocumentDriveLocalState, action: AddTriggerAction, dispatch?: SignalDispatch) => void;
+    removeTriggerOperation: (state: DocumentDriveLocalState, action: RemoveTriggerAction, dispatch?: SignalDispatch) => void;
+}

package/dist/document-models/document-drive/gen/index.d.ts

@@ -0,0 +1,5 @@
+export * from './actions';
+export * from './document-model';
+export * from './object';
+export * from './types';
+export * as actions from './creators';

package/dist/document-models/document-drive/gen/node/actions.d.ts

@@ -0,0 +1,10 @@
+import { Action } from 'document-model/document';
+import { AddFileInput, AddFolderInput, DeleteNodeInput, UpdateFileInput, UpdateNodeInput, CopyNodeInput, MoveNodeInput } from '../types';
+export type AddFileAction = Action<"ADD_FILE", AddFileInput, "global">;
+export type AddFolderAction = Action<"ADD_FOLDER", AddFolderInput, "global">;
+export type DeleteNodeAction = Action<"DELETE_NODE", DeleteNodeInput, "global">;
+export type UpdateFileAction = Action<"UPDATE_FILE", UpdateFileInput, "global">;
+export type UpdateNodeAction = Action<"UPDATE_NODE", UpdateNodeInput, "global">;
+export type CopyNodeAction = Action<"COPY_NODE", CopyNodeInput, "global">;
+export type MoveNodeAction = Action<"MOVE_NODE", MoveNodeInput, "global">;
+export type DocumentDriveNodeAction = AddFileAction | AddFolderAction | DeleteNodeAction | UpdateFileAction | UpdateNodeAction | CopyNodeAction | MoveNodeAction;

package/dist/document-models/document-drive/gen/node/creators.d.ts

@@ -0,0 +1,9 @@
+import { AddFileInput, AddFolderInput, DeleteNodeInput, UpdateFileInput, UpdateNodeInput, CopyNodeInput, MoveNodeInput } from '../types';
+import { AddFileAction, AddFolderAction, DeleteNodeAction, UpdateFileAction, UpdateNodeAction, CopyNodeAction, MoveNodeAction } from './actions';
+export declare const addFile: (input: AddFileInput) => AddFileAction;
+export declare const addFolder: (input: AddFolderInput) => AddFolderAction;
+export declare const deleteNode: (input: DeleteNodeInput) => DeleteNodeAction;
+export declare const updateFile: (input: UpdateFileInput) => UpdateFileAction;
+export declare const updateNode: (input: UpdateNodeInput) => UpdateNodeAction;
+export declare const copyNode: (input: CopyNodeInput) => CopyNodeAction;
+export declare const moveNode: (input: MoveNodeInput) => MoveNodeAction;

package/dist/document-models/document-drive/gen/node/error.d.ts

@@ -0,0 +1 @@
+export declare const errors: {};

package/dist/document-models/document-drive/gen/node/object.d.ts

@@ -0,0 +1,12 @@
+import { BaseDocument } from 'document-model/document';
+import { AddFileInput, AddFolderInput, DeleteNodeInput, UpdateFileInput, UpdateNodeInput, CopyNodeInput, MoveNodeInput, DocumentDriveState, DocumentDriveLocalState } from '../types';
+import { DocumentDriveAction } from '../actions';
+export default class DocumentDrive_Node extends BaseDocument<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState> {
+    addFile(input: AddFileInput): this;
+    addFolder(input: AddFolderInput): this;
+    deleteNode(input: DeleteNodeInput): this;
+    updateFile(input: UpdateFileInput): this;
+    updateNode(input: UpdateNodeInput): this;
+    copyNode(input: CopyNodeInput): this;
+    moveNode(input: MoveNodeInput): this;
+}

package/dist/document-models/document-drive/gen/node/operations.d.ts

@@ -0,0 +1,12 @@
+import { SignalDispatch } from 'document-model/document';
+import { AddFileAction, AddFolderAction, DeleteNodeAction, UpdateFileAction, UpdateNodeAction, CopyNodeAction, MoveNodeAction } from './actions';
+import { DocumentDriveState } from '../types';
+export interface DocumentDriveNodeOperations {
+    addFileOperation: (state: DocumentDriveState, action: AddFileAction, dispatch?: SignalDispatch) => void;
+    addFolderOperation: (state: DocumentDriveState, action: AddFolderAction, dispatch?: SignalDispatch) => void;
+    deleteNodeOperation: (state: DocumentDriveState, action: DeleteNodeAction, dispatch?: SignalDispatch) => void;
+    updateFileOperation: (state: DocumentDriveState, action: UpdateFileAction, dispatch?: SignalDispatch) => void;
+    updateNodeOperation: (state: DocumentDriveState, action: UpdateNodeAction, dispatch?: SignalDispatch) => void;
+    copyNodeOperation: (state: DocumentDriveState, action: CopyNodeAction, dispatch?: SignalDispatch) => void;
+    moveNodeOperation: (state: DocumentDriveState, action: MoveNodeAction, dispatch?: SignalDispatch) => void;
+}

package/dist/document-models/document-drive/gen/object.d.ts

@@ -0,0 +1,17 @@
+import { BaseDocument, ExtendedState, PartialState, SignalDispatch } from 'document-model/document';
+import { DocumentDriveState, DocumentDriveLocalState } from './types';
+import { DocumentDriveAction } from './actions';
+import { default as DocumentDrive_Node } from './node/object';
+import { default as DocumentDrive_Drive } from './drive/object';
+export * from './node/object';
+export * from './drive/object';
+interface DocumentDrive extends DocumentDrive_Node, DocumentDrive_Drive {
+}
+declare class DocumentDrive extends BaseDocument<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState> {
+    static fileExtension: string;
+    constructor(initialState?: Partial<ExtendedState<PartialState<DocumentDriveState>, PartialState<DocumentDriveLocalState>>>, dispatch?: SignalDispatch);
+    saveToFile(path: string, name?: string): Promise<string>;
+    loadFromFile(path: string): Promise<void>;
+    static fromFile(path: string): Promise<DocumentDrive>;
+}
+export { DocumentDrive };

package/dist/document-models/document-drive/gen/reducer.d.ts

@@ -0,0 +1,3 @@
+import { DocumentDriveState, DocumentDriveLocalState } from './types';
+import { DocumentDriveAction } from './actions';
+export declare const reducer: import('document-model/document').Reducer<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState>;

package/dist/document-models/document-drive/gen/schema/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * as z from './zod';

package/dist/document-models/document-drive/gen/schema/types.d.ts

@@ -0,0 +1,175 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = T | null | undefined;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Unknown: {
+        input: unknown;
+        output: unknown;
+    };
+};
+export type AddFileInput = {
+    document?: InputMaybe<Scalars["Unknown"]["input"]>;
+    documentType: Scalars["String"]["input"];
+    id: Scalars["ID"]["input"];
+    name: Scalars["String"]["input"];
+    parentFolder?: InputMaybe<Scalars["ID"]["input"]>;
+    synchronizationUnits: Array<SynchronizationUnit>;
+};
+export type AddFolderInput = {
+    id: Scalars["ID"]["input"];
+    name: Scalars["String"]["input"];
+    parentFolder?: InputMaybe<Scalars["ID"]["input"]>;
+};
+export type AddListenerInput = {
+    listener: Listener;
+};
+export type AddTriggerInput = {
+    trigger: Trigger;
+};
+export type CopyNodeInput = {
+    srcId: Scalars["ID"]["input"];
+    synchronizationUnits?: InputMaybe<Array<SynchronizationUnit>>;
+    targetId: Scalars["ID"]["input"];
+    targetName?: InputMaybe<Scalars["String"]["input"]>;
+    targetParentFolder?: InputMaybe<Scalars["ID"]["input"]>;
+};
+export type DeleteNodeInput = {
+    id: Scalars["ID"]["input"];
+};
+export type DocumentDriveLocalState = {
+    availableOffline: Scalars["Boolean"]["output"];
+    listeners: Array<Listener>;
+    sharingType: Maybe<Scalars["String"]["output"]>;
+    triggers: Array<Trigger>;
+};
+export type DocumentDriveState = {
+    icon: Maybe<Scalars["String"]["output"]>;
+    id: Scalars["ID"]["output"];
+    name: Scalars["String"]["output"];
+    nodes: Array<Node>;
+    slug: Maybe<Scalars["String"]["output"]>;
+};
+export type FileNode = {
+    documentType: Scalars["String"]["output"];
+    id: Scalars["String"]["output"];
+    kind: Scalars["String"]["output"];
+    name: Scalars["String"]["output"];
+    parentFolder: Maybe<Scalars["String"]["output"]>;
+    synchronizationUnits: Array<SynchronizationUnit>;
+};
+export type FolderNode = {
+    id: Scalars["String"]["output"];
+    kind: Scalars["String"]["output"];
+    name: Scalars["String"]["output"];
+    parentFolder: Maybe<Scalars["String"]["output"]>;
+};
+export type Listener = {
+    block: Scalars["Boolean"]["output"];
+    callInfo: Maybe<ListenerCallInfo>;
+    filter: ListenerFilter;
+    label: Maybe<Scalars["String"]["output"]>;
+    listenerId: Scalars["ID"]["output"];
+    system: Scalars["Boolean"]["output"];
+};
+export type ListenerCallInfo = {
+    data: Maybe<Scalars["String"]["output"]>;
+    name: Maybe<Scalars["String"]["output"]>;
+    transmitterType: Maybe<TransmitterType | `${TransmitterType}`>;
+};
+export type ListenerFilter = {
+    branch: Maybe<Array<Scalars["String"]["output"]>>;
+    documentId: Maybe<Array<Scalars["ID"]["output"]>>;
+    documentType: Array<Scalars["String"]["output"]>;
+    scope: Maybe<Array<Scalars["String"]["output"]>>;
+};
+export type MoveNodeInput = {
+    srcFolder: Scalars["ID"]["input"];
+    targetParentFolder?: InputMaybe<Scalars["ID"]["input"]>;
+};
+export type Node = FileNode | FolderNode;
+export type PullResponderTriggerData = {
+    interval: Scalars["String"]["output"];
+    listenerId: Scalars["ID"]["output"];
+    url: Scalars["String"]["output"];
+};
+export type RemoveListenerInput = {
+    listenerId: Scalars["String"]["input"];
+};
+export type RemoveTriggerInput = {
+    triggerId: Scalars["String"]["input"];
+};
+export type SetAvailableOfflineInput = {
+    availableOffline: Scalars["Boolean"]["input"];
+};
+export type SetDriveIconInput = {
+    icon: Scalars["String"]["input"];
+};
+export type SetDriveNameInput = {
+    name: Scalars["String"]["input"];
+};
+export type SetSharingTypeInput = {
+    type: Scalars["String"]["input"];
+};
+export type SynchronizationUnit = {
+    branch: Scalars["String"]["output"];
+    scope: Scalars["String"]["output"];
+    syncId: Scalars["ID"]["output"];
+};
+export type TransmitterType = "Internal" | "MatrixConnect" | "PullResponder" | "RESTWebhook" | "SecureConnect" | "SwitchboardPush";
+export type Trigger = {
+    data: Maybe<TriggerData>;
+    id: Scalars["ID"]["output"];
+    type: TriggerType | `${TriggerType}`;
+};
+export type TriggerData = PullResponderTriggerData;
+export type TriggerType = "PullResponder";
+export type UpdateFileInput = {
+    documentType?: InputMaybe<Scalars["String"]["input"]>;
+    id: Scalars["ID"]["input"];
+    name?: InputMaybe<Scalars["String"]["input"]>;
+    parentFolder?: InputMaybe<Scalars["ID"]["input"]>;
+};
+export type UpdateNodeInput = {
+    id: Scalars["ID"]["input"];
+    name?: InputMaybe<Scalars["String"]["input"]>;
+    parentFolder?: InputMaybe<Scalars["ID"]["input"]>;
+};

package/dist/document-models/document-drive/gen/schema/zod.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { AddFileInput, AddFolderInput, AddListenerInput, AddTriggerInput, CopyNodeInput, DeleteNodeInput, DocumentDriveLocalState, DocumentDriveState, FileNode, FolderNode, Listener, ListenerCallInfo, ListenerFilter, MoveNodeInput, PullResponderTriggerData, RemoveListenerInput, RemoveTriggerInput, SetAvailableOfflineInput, SetDriveIconInput, SetDriveNameInput, SetSharingTypeInput, SynchronizationUnit, Trigger, UpdateFileInput, UpdateNodeInput } from './types';
+type Properties<T> = Required<{
+    [K in keyof T]: z.ZodType<T[K], any, T[K]>;
+}>;
+type definedNonNullAny = {};
+export declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
+export declare const definedNonNullAnySchema: z.ZodEffects<z.ZodAny, definedNonNullAny, any>;
+export declare const TransmitterTypeSchema: z.ZodEnum<["Internal", "MatrixConnect", "PullResponder", "RESTWebhook", "SecureConnect", "SwitchboardPush"]>;
+export declare const TriggerTypeSchema: z.ZodEnum<["PullResponder"]>;
+export declare function AddFileInputSchema(): z.ZodObject<Properties<AddFileInput>>;
+export declare function AddFolderInputSchema(): z.ZodObject<Properties<AddFolderInput>>;
+export declare function AddListenerInputSchema(): z.ZodObject<Properties<AddListenerInput>>;
+export declare function AddTriggerInputSchema(): z.ZodObject<Properties<AddTriggerInput>>;
+export declare function CopyNodeInputSchema(): z.ZodObject<Properties<CopyNodeInput>>;
+export declare function DeleteNodeInputSchema(): z.ZodObject<Properties<DeleteNodeInput>>;
+export declare function DocumentDriveLocalStateSchema(): z.ZodObject<Properties<DocumentDriveLocalState>>;
+export declare function DocumentDriveStateSchema(): z.ZodObject<Properties<DocumentDriveState>>;
+export declare function FileNodeSchema(): z.ZodObject<Properties<FileNode>>;
+export declare function FolderNodeSchema(): z.ZodObject<Properties<FolderNode>>;
+export declare function ListenerSchema(): z.ZodObject<Properties<Listener>>;
+export declare function ListenerCallInfoSchema(): z.ZodObject<Properties<ListenerCallInfo>>;
+export declare function ListenerFilterSchema(): z.ZodObject<Properties<ListenerFilter>>;
+export declare function MoveNodeInputSchema(): z.ZodObject<Properties<MoveNodeInput>>;
+export declare function NodeSchema(): z.ZodUnion<[z.ZodObject<Required<{
+    documentType: z.ZodType<string, any, string>;
+    id: z.ZodType<string, any, string>;
+    kind: z.ZodType<string, any, string>;
+    name: z.ZodType<string, any, string>;
+    parentFolder: z.ZodType<import('./types').Maybe<string>, any, import('./types').Maybe<string>>;
+    synchronizationUnits: z.ZodType<SynchronizationUnit[], any, SynchronizationUnit[]>;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    documentType: import('./types').Scalars["String"]["output"];
+    id: import('./types').Scalars["String"]["output"];
+    name: import('./types').Scalars["String"]["output"];
+    parentFolder: import('./types').Maybe<import('./types').Scalars["String"]["output"]>;
+    synchronizationUnits: Array<SynchronizationUnit>;
+    kind: import('./types').Scalars["String"]["output"];
+}, {
+    documentType: import('./types').Scalars["String"]["output"];
+    id: import('./types').Scalars["String"]["output"];
+    name: import('./types').Scalars["String"]["output"];
+    parentFolder: import('./types').Maybe<import('./types').Scalars["String"]["output"]>;
+    synchronizationUnits: Array<SynchronizationUnit>;
+    kind: import('./types').Scalars["String"]["output"];
+}>, z.ZodObject<Required<{
+    id: z.ZodType<string, any, string>;
+    kind: z.ZodType<string, any, string>;
+    name: z.ZodType<string, any, string>;
+    parentFolder: z.ZodType<import('./types').Maybe<string>, any, import('./types').Maybe<string>>;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    id: import('./types').Scalars["String"]["output"];
+    name: import('./types').Scalars["String"]["output"];
+    parentFolder: import('./types').Maybe<import('./types').Scalars["String"]["output"]>;
+    kind: import('./types').Scalars["String"]["output"];
+}, {
+    id: import('./types').Scalars["String"]["output"];
+    name: import('./types').Scalars["String"]["output"];
+    parentFolder: import('./types').Maybe<import('./types').Scalars["String"]["output"]>;
+    kind: import('./types').Scalars["String"]["output"];
+}>]>;
+export declare function PullResponderTriggerDataSchema(): z.ZodObject<Properties<PullResponderTriggerData>>;
+export declare function RemoveListenerInputSchema(): z.ZodObject<Properties<RemoveListenerInput>>;
+export declare function RemoveTriggerInputSchema(): z.ZodObject<Properties<RemoveTriggerInput>>;
+export declare function SetAvailableOfflineInputSchema(): z.ZodObject<Properties<SetAvailableOfflineInput>>;
+export declare function SetDriveIconInputSchema(): z.ZodObject<Properties<SetDriveIconInput>>;
+export declare function SetDriveNameInputSchema(): z.ZodObject<Properties<SetDriveNameInput>>;
+export declare function SetSharingTypeInputSchema(): z.ZodObject<Properties<SetSharingTypeInput>>;
+export declare function SynchronizationUnitSchema(): z.ZodObject<Properties<SynchronizationUnit>>;
+export declare function TriggerSchema(): z.ZodObject<Properties<Trigger>>;
+export declare function TriggerDataSchema(): z.ZodObject<Required<{
+    interval: z.ZodType<string, any, string>;
+    listenerId: z.ZodType<string, any, string>;
+    url: z.ZodType<string, any, string>;
+}>, z.UnknownKeysParam, z.ZodTypeAny, {
+    listenerId: import('./types').Scalars["ID"]["output"];
+    interval: import('./types').Scalars["String"]["output"];
+    url: import('./types').Scalars["String"]["output"];
+}, {
+    listenerId: import('./types').Scalars["ID"]["output"];
+    interval: import('./types').Scalars["String"]["output"];
+    url: import('./types').Scalars["String"]["output"];
+}>;
+export declare function UpdateFileInputSchema(): z.ZodObject<Properties<UpdateFileInput>>;
+export declare function UpdateNodeInputSchema(): z.ZodObject<Properties<UpdateNodeInput>>;
+export {};

package/dist/document-models/document-drive/gen/types.d.ts

@@ -0,0 +1,8 @@
+import { Document, ExtendedState } from 'document-model/document';
+import { DocumentDriveState, DocumentDriveLocalState } from './schema/types';
+import { DocumentDriveAction } from './actions';
+export { z } from './schema';
+export type * from './schema/types';
+export type ExtendedDocumentDriveState = ExtendedState<DocumentDriveState, DocumentDriveLocalState>;
+export type DocumentDriveDocument = Document<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState>;
+export { DocumentDriveState, DocumentDriveLocalState, DocumentDriveAction };

package/dist/document-models/document-drive/gen/utils.d.ts

@@ -0,0 +1,6 @@
+import { DocumentModelUtils } from 'document-model/document';
+import { DocumentDriveAction, DocumentDriveState, DocumentDriveLocalState } from './types';
+export declare const initialGlobalState: DocumentDriveState;
+export declare const initialLocalState: DocumentDriveLocalState;
+declare const utils: DocumentModelUtils<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState>;
+export default utils;

package/dist/document-models/document-drive/index.d.ts

@@ -0,0 +1,60 @@
+import { DocumentModel } from 'document-model/document';
+import { DocumentDrive } from './gen';
+import { reducer } from './gen/reducer';
+import { documentModel } from './gen/document-model';
+import { DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState } from './gen/types';
+import * as customUtils from "./src/utils";
+declare const Document: typeof DocumentDrive;
+declare const utils: {
+    isFileNode(node: import('./gen').Node): node is import('./gen').FileNode;
+    isFolderNode(node: import('./gen').Node): node is import('./gen').FolderNode;
+    getAncestors(node: import('./gen').Node, allNodes: import('./gen').Node[]): import('./gen').Node[];
+    getDescendants(node: import('./gen').Node, allNodes: import('./gen').Node[]): import('./gen').Node[];
+    generateNodesCopy(src: customUtils.GenerateNodesCopySrc, idGenerator: customUtils.GenerateNodesCopyIdGenerator, nodes: import('./gen').Node[]): import('./gen').CopyNodeInput[];
+    generateSynchronizationUnitId(nodes: DocumentDriveState["nodes"]): string;
+    generateSynchronizationUnits(state: DocumentDriveState, scopes: import('document-model/document').OperationScope[], branch?: string): import('document-model/document').SynchronizationUnit[];
+    generateAddNodeAction(state: DocumentDriveState, action: Omit<import('./gen').AddFileInput, "synchronizationUnits">, scopes: import('document-model/document').OperationScope[]): import('./gen').AddFileAction;
+    generateCopyNodeAction(state: DocumentDriveState, action: Omit<import('./gen').CopyNodeInput, "synchronizationUnits">): import('./gen').CopyNodeAction;
+    getNextCopyNumber(files: string[], baseFilename: string): number;
+    escapeRegExp(string: string): string;
+    handleTargetNameCollisions(params: {
+        nodes: import('./gen').Node[];
+        targetParentFolder: string | null;
+        srcName: string;
+    }): string;
+    fileExtension: string;
+    createState: import('document-model/document').CreateState<DocumentDriveState, DocumentDriveLocalState>;
+    createExtendedState: (extendedState?: Partial<import('document-model/document').ExtendedState<import('document-model/document').PartialState<DocumentDriveState>, import('document-model/document').PartialState<DocumentDriveLocalState>>> | undefined, createState?: import('document-model/document').CreateState<DocumentDriveState, DocumentDriveLocalState> | undefined) => import('document-model/document').ExtendedState<DocumentDriveState, DocumentDriveLocalState>;
+    createDocument: (document?: Partial<import('document-model/document').ExtendedState<import('document-model/document').PartialState<DocumentDriveState>, import('document-model/document').PartialState<DocumentDriveLocalState>>> | undefined, createState?: import('document-model/document').CreateState<DocumentDriveState, DocumentDriveLocalState> | undefined) => import('document-model/document').Document<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState>;
+    loadFromFile: (path: string) => Promise<import('document-model/document').Document<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState>>;
+    loadFromInput: (input: import('document-model/document').FileInput) => Promise<import('document-model/document').Document<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState>>;
+    saveToFile: (document: import('document-model/document').Document<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState>, path: string, name?: string) => Promise<string>;
+    saveToFileHandle: (document: import('document-model/document').Document<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState>, input: FileSystemFileHandle) => Promise<void>;
+};
+declare const actions: {
+    addFile: (input: import('./gen').AddFileInput) => import('./gen').AddFileAction;
+    addFolder: (input: import('./gen').AddFolderInput) => import('./gen').AddFolderAction;
+    deleteNode: (input: import('./gen').DeleteNodeInput) => import('./gen').DeleteNodeAction;
+    updateFile: (input: import('./gen').UpdateFileInput) => import('./gen').UpdateFileAction;
+    updateNode: (input: import('./gen').UpdateNodeInput) => import('./gen').UpdateNodeAction;
+    copyNode: (input: import('./gen').CopyNodeInput) => import('./gen').CopyNodeAction;
+    moveNode: (input: import('./gen').MoveNodeInput) => import('./gen').MoveNodeAction;
+    setDriveName: (input: import('./gen').SetDriveNameInput) => import('./gen').SetDriveNameAction;
+    setDriveIcon: (input: import('./gen').SetDriveIconInput) => import('./gen').SetDriveIconAction;
+    setSharingType: (input: import('./gen').SetSharingTypeInput) => import('./gen').SetSharingTypeAction;
+    setAvailableOffline: (input: import('./gen').SetAvailableOfflineInput) => import('./gen').SetAvailableOfflineAction;
+    addListener: (input: import('./gen').AddListenerInput) => import('./gen').AddListenerAction;
+    removeListener: (input: import('./gen').RemoveListenerInput) => import('./gen').RemoveListenerAction;
+    addTrigger: (input: import('./gen').AddTriggerInput) => import('./gen').AddTriggerAction;
+    removeTrigger: (input: import('./gen').RemoveTriggerInput) => import('./gen').RemoveTriggerAction;
+    setName: (name: string) => import('node_modules/document-model/dist/browser/src/document/actions/types').SetNameAction;
+    undo: (skip?: number, scope?: import('document-model/document').OperationScope) => import('node_modules/document-model/dist/browser/src/document/actions/types').UndoAction;
+    redo: (count?: number, scope?: import('document-model/document').OperationScope) => import('node_modules/document-model/dist/browser/src/document/actions/types').RedoAction;
+    prune: (start?: number | undefined, end?: number | undefined, scope?: import('document-model/document').OperationScope) => import('node_modules/document-model/dist/browser/src/document/actions/types').PruneAction;
+    loadState: <S, T>(state: Pick<import('document-model/document').ExtendedState<S, T>, "state" | "name">, operations: number) => import('node_modules/document-model/dist/browser/src/document/actions/types').LoadStateAction;
+    noop: (scope?: import('document-model/document').OperationScope) => import('node_modules/document-model/dist/browser/src/document/actions/types').NOOPAction;
+};
+export declare const module: DocumentModel<DocumentDriveState, DocumentDriveAction, DocumentDriveLocalState>;
+export { DocumentDrive, Document, reducer, actions, utils, documentModel };
+export * from './gen/types';
+export * from './src/utils';

package/dist/document-models/document-drive/src/reducers/drive.d.ts

@@ -0,0 +1,2 @@
+import { DocumentDriveDriveOperations } from '../../gen/drive/operations';
+export declare const reducer: DocumentDriveDriveOperations;

package/dist/document-models/document-drive/src/reducers/node.d.ts

@@ -0,0 +1,2 @@
+import { DocumentDriveNodeOperations } from '../../gen/node/operations';
+export declare const reducer: DocumentDriveNodeOperations;

package/dist/document-models/document-drive/src/tests/actions.test.d.ts

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

package/dist/document-models/document-drive/src/tests/base.test.d.ts

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

package/dist/document-models/document-drive/src/tests/document-model.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+export {};

package/dist/document-models/document-drive/src/tests/drive.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+export {};

package/dist/document-models/document-drive/src/tests/node.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+export {};

package/dist/document-models/document-drive/src/tests/utils.test.d.ts

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

package/dist/document-models/document-drive/src/utils.d.ts

@@ -0,0 +1,33 @@
+import { AddFileInput, CopyNodeInput, DocumentDriveState, FileNode, FolderNode, Node } from '..';
+import { OperationScope, SynchronizationUnit } from 'document-model/document';
+import { AddFileAction, CopyNodeAction } from '../gen/node/actions';
+export declare function isFileNode(node: Node): node is FileNode;
+export declare function isFolderNode(node: Node): node is FolderNode;
+export declare function getAncestors(node: Node, allNodes: Node[]): Node[];
+export declare function getDescendants(node: Node, allNodes: Node[]): Node[];
+export type GenerateNodesCopySrc = {
+    srcId: Node["id"];
+    targetName?: Node["name"];
+    targetParentFolder?: Node["parentFolder"];
+};
+export type GenerateNodesCopyIdGenerator = (prevId: Node["id"]) => Node["id"];
+/**
+ * Generates a copy of nodes based on the provided source and target information.
+ * @param src - The source information for generating the copy.
+ * @param idGenerator - The function used to generate new IDs for the copied nodes.
+ * @param nodes - The array of nodes to copy from.
+ * @returns An array of copied nodes with updated IDs and parent folders.
+ * @throws Error if the root node with the specified ID is not found.
+ */
+export declare function generateNodesCopy(src: GenerateNodesCopySrc, idGenerator: GenerateNodesCopyIdGenerator, nodes: Node[]): CopyNodeInput[];
+export declare function generateSynchronizationUnitId(nodes: DocumentDriveState["nodes"]): string;
+export declare function generateSynchronizationUnits(state: DocumentDriveState, scopes: OperationScope[], branch?: string): SynchronizationUnit[];
+export declare function generateAddNodeAction(state: DocumentDriveState, action: Omit<AddFileInput, "synchronizationUnits">, scopes: OperationScope[]): AddFileAction;
+export declare function generateCopyNodeAction(state: DocumentDriveState, action: Omit<CopyNodeInput, "synchronizationUnits">): CopyNodeAction;
+export declare function getNextCopyNumber(files: string[], baseFilename: string): number;
+export declare function escapeRegExp(string: string): string;
+export declare function handleTargetNameCollisions(params: {
+    nodes: Node[];
+    targetParentFolder: string | null;
+    srcName: string;
+}): string;

package/dist/document-models/index.d.ts

@@ -0,0 +1 @@
+export { module as DocumentDrive } from './document-drive';

package/dist/documentModels.d.ts

@@ -0,0 +1,2 @@
+export * from './document-models/index'
+export {}

package/dist/editors/generic-drive-explorer/components/create-document.d.ts

@@ -0,0 +1,7 @@
+import { DocumentModel } from 'document-model/document';
+interface CreateDocumentProps {
+    documentModels?: DocumentModel[];
+    createDocument: (doc: DocumentModel) => void;
+}
+export declare const CreateDocument: React.FC<CreateDocumentProps>;
+export {};

package/dist/editors/generic-drive-explorer/components/file-content-view.d.ts

@@ -0,0 +1,11 @@
+import { UiFileNode } from '@powerhousedao/design-system';
+type Props = {
+    fileNodes: UiFileNode[];
+    onSelectNode: (uiNode: UiFileNode) => void;
+    onRenameNode: (name: string, uiNode: UiFileNode) => void;
+    onDuplicateNode: (uiNode: UiFileNode) => void;
+    onDeleteNode: (uiNode: UiFileNode) => void;
+    isAllowedToCreateDocuments: boolean;
+};
+export declare function FileContentView(props: Props): import("react/jsx-runtime").JSX.Element;
+export default FileContentView;