import { A as Action, D as Document, B as BaseDocument, a as BaseAction, S as SetNameAction, U as UndoAction, R as RedoAction, P as PruneAction, L as LoadStateAction } from './object-15563a59.js';
import { Z as ZodEffects, a as ZodAny, b as ZodObject, c as ZodUnion, d as ZodType, U as UnknownKeysParam, e as ZodTypeAny, f as ZodEnum } from './types.d-e18ae19e.js';
import { F as FileInput } from './file-3215c4d4.js';

type Maybe<T> = T | null;
type InputMaybe<T> = T | null | undefined;
type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
/** All built-in and custom scalars, mapped to their actual values */
type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
};
type AddElementInput = {
    __typename?: 'AddElementInput';
    components: Maybe<ElementComponents>;
    id: Scalars['String'];
    name: Maybe<Scalars['String']>;
    path: Scalars['String'];
    type: ScopeFrameworkElementType | `${ScopeFrameworkElementType}`;
};
type ArticleComponent = {
    __typename?: 'ArticleComponent';
    content: Maybe<Scalars['String']>;
};
type CoreComponent = {
    __typename?: 'CoreComponent';
    content: Maybe<Scalars['String']>;
};
type ElementComponents = ArticleComponent | CoreComponent | ScopeComponent | SectionComponent | TypeSpecificationComponent;
type MoveElementInput = {
    __typename?: 'MoveElementInput';
    id: Scalars['ID'];
    newParentId: Scalars['ID'];
};
type Mutation = {
    __typename?: 'Mutation';
    addElement: Maybe<ScopeFrameworkState>;
    moveElement: Maybe<ScopeFrameworkState>;
    removeElement: Maybe<ScopeFrameworkState>;
    reorderElements: Maybe<ScopeFrameworkState>;
    setRootPath: Maybe<ScopeFrameworkState>;
    updateElementComponents: Maybe<ScopeFrameworkState>;
    updateElementName: Maybe<ScopeFrameworkState>;
    updateElementType: Maybe<ScopeFrameworkState>;
};
type MutationAddElementArgs = {
    input: AddElementInput;
};
type MutationMoveElementArgs = {
    input: MoveElementInput;
};
type MutationRemoveElementArgs = {
    input: RemoveElementInput;
};
type MutationReorderElementsArgs = {
    input: ReorderElementsInput;
};
type MutationSetRootPathArgs = {
    input: SetRootPathInput;
};
type MutationUpdateElementComponentsArgs = {
    input: UpdateElementComponentsInput;
};
type MutationUpdateElementNameArgs = {
    input: UpdateElementNameInput;
};
type MutationUpdateElementTypeArgs = {
    input: UpdateElementTypeInput;
};
type RemoveElementInput = {
    __typename?: 'RemoveElementInput';
    id: Scalars['ID'];
};
type ReorderElementsInput = {
    __typename?: 'ReorderElementsInput';
    order: Array<Scalars['ID']>;
    parentElementId: Scalars['ID'];
};
type ScopeComponent = {
    __typename?: 'ScopeComponent';
    content: Maybe<Scalars['String']>;
};
type ScopeFrameworkElement = {
    __typename?: 'ScopeFrameworkElement';
    components: Maybe<ElementComponents>;
    id: Scalars['ID'];
    name: Maybe<Scalars['String']>;
    path: Scalars['String'];
    type: Maybe<ScopeFrameworkElementType | `${ScopeFrameworkElementType}`>;
    version: Scalars['Int'];
};
type ScopeFrameworkElementType = 'Article' | 'Core' | 'Scope' | 'Section' | 'TypeSpecification';
type ScopeFrameworkInput = AddElementInput | MoveElementInput | RemoveElementInput | ReorderElementsInput | SetRootPathInput | UpdateElementComponentsInput | UpdateElementNameInput | UpdateElementTypeInput;
type ScopeFrameworkState = {
    __typename?: 'ScopeFrameworkState';
    elements: Array<ScopeFrameworkElement>;
    rootPath: Scalars['String'];
};
type SectionComponent = {
    __typename?: 'SectionComponent';
    content: Maybe<Scalars['String']>;
};
type SetRootPathInput = {
    __typename?: 'SetRootPathInput';
    newRootPath: Scalars['String'];
};
type TypeSpecificationComponent = {
    __typename?: 'TypeSpecificationComponent';
    additionalLogic: Maybe<Scalars['String']>;
    category: Maybe<TypeSpecificationComponentCategory | `${TypeSpecificationComponentCategory}`>;
    documentIdentifierRules: Maybe<Scalars['String']>;
    name: Maybe<Scalars['String']>;
    overview: Maybe<Scalars['String']>;
    typeAuthority: Maybe<Scalars['String']>;
};
type TypeSpecificationComponentCategory = 'Accessory' | 'Immutable' | 'Primary' | 'Supporting';
type UpdateElementComponentsInput = {
    __typename?: 'UpdateElementComponentsInput';
    components: Maybe<ElementComponents>;
    id: Scalars['ID'];
};
type UpdateElementNameInput = {
    __typename?: 'UpdateElementNameInput';
    id: Scalars['ID'];
    name: Maybe<Scalars['String']>;
};
type UpdateElementTypeInput = {
    __typename?: 'UpdateElementTypeInput';
    id: Scalars['ID'];
    type: ScopeFrameworkElementType | `${ScopeFrameworkElementType}`;
};

type Properties<T> = Required<{
    [K in keyof T]: ZodType<T[K], any, T[K]>;
}>;
type definedNonNullAny = {};
declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
declare const definedNonNullAnySchema: ZodEffects<ZodAny, any, any>;
declare function AddElementInputSchema(): ZodObject<Properties<AddElementInput>>;
declare function ArticleComponentSchema(): ZodObject<Properties<ArticleComponent>>;
declare function CoreComponentSchema(): ZodObject<Properties<CoreComponent>>;
declare function ElementComponentsSchema(): ZodUnion<[ZodObject<Required<{
    __typename?: ZodType<"ArticleComponent" | undefined, any, "ArticleComponent" | undefined> | undefined;
    content: ZodType<Maybe<string>, any, Maybe<string>>;
}>, UnknownKeysParam, ZodTypeAny, {
    content: string | null;
    __typename?: "ArticleComponent" | undefined;
}, {
    content: string | null;
    __typename?: "ArticleComponent" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"CoreComponent" | undefined, any, "CoreComponent" | undefined> | undefined;
    content: ZodType<Maybe<string>, any, Maybe<string>>;
}>, UnknownKeysParam, ZodTypeAny, {
    content: string | null;
    __typename?: "CoreComponent" | undefined;
}, {
    content: string | null;
    __typename?: "CoreComponent" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"ScopeComponent" | undefined, any, "ScopeComponent" | undefined> | undefined;
    content: ZodType<Maybe<string>, any, Maybe<string>>;
}>, UnknownKeysParam, ZodTypeAny, {
    content: string | null;
    __typename?: "ScopeComponent" | undefined;
}, {
    content: string | null;
    __typename?: "ScopeComponent" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"SectionComponent" | undefined, any, "SectionComponent" | undefined> | undefined;
    content: ZodType<Maybe<string>, any, Maybe<string>>;
}>, UnknownKeysParam, ZodTypeAny, {
    content: string | null;
    __typename?: "SectionComponent" | undefined;
}, {
    content: string | null;
    __typename?: "SectionComponent" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"TypeSpecificationComponent" | undefined, any, "TypeSpecificationComponent" | undefined> | undefined;
    additionalLogic: ZodType<Maybe<string>, any, Maybe<string>>;
    category: ZodType<Maybe<TypeSpecificationComponentCategory>, any, Maybe<TypeSpecificationComponentCategory>>;
    documentIdentifierRules: ZodType<Maybe<string>, any, Maybe<string>>;
    name: ZodType<Maybe<string>, any, Maybe<string>>;
    overview: ZodType<Maybe<string>, any, Maybe<string>>;
    typeAuthority: ZodType<Maybe<string>, any, Maybe<string>>;
}>, UnknownKeysParam, ZodTypeAny, {
    name: string | null;
    category: "Accessory" | "Immutable" | "Primary" | "Supporting" | null;
    additionalLogic: string | null;
    documentIdentifierRules: string | null;
    overview: string | null;
    typeAuthority: string | null;
    __typename?: "TypeSpecificationComponent" | undefined;
}, {
    name: string | null;
    category: "Accessory" | "Immutable" | "Primary" | "Supporting" | null;
    additionalLogic: string | null;
    documentIdentifierRules: string | null;
    overview: string | null;
    typeAuthority: string | null;
    __typename?: "TypeSpecificationComponent" | undefined;
}>]>;
declare function MoveElementInputSchema(): ZodObject<Properties<MoveElementInput>>;
declare function RemoveElementInputSchema(): ZodObject<Properties<RemoveElementInput>>;
declare function ReorderElementsInputSchema(): ZodObject<Properties<ReorderElementsInput>>;
declare function ScopeComponentSchema(): ZodObject<Properties<ScopeComponent>>;
declare function ScopeFrameworkElementSchema(): ZodObject<Properties<ScopeFrameworkElement>>;
declare const ScopeFrameworkElementTypeSchema: ZodEnum<["Article", "Core", "Scope", "Section", "TypeSpecification"]>;
declare function ScopeFrameworkInputSchema(): ZodUnion<[ZodObject<Required<{
    __typename?: ZodType<"AddElementInput" | undefined, any, "AddElementInput" | undefined> | undefined;
    components: ZodType<Maybe<ElementComponents>, any, Maybe<ElementComponents>>;
    id: ZodType<string, any, string>;
    name: ZodType<Maybe<string>, any, Maybe<string>>;
    path: ZodType<string, any, string>;
    type: ZodType<ScopeFrameworkElementType, any, ScopeFrameworkElementType>;
}>, UnknownKeysParam, ZodTypeAny, {
    path: string;
    type: "Article" | "Core" | "Scope" | "Section" | "TypeSpecification";
    name: string | null;
    id: string;
    components: (ElementComponents & (ArticleComponent | CoreComponent | ScopeComponent | SectionComponent | TypeSpecificationComponent | undefined)) | null;
    __typename?: "AddElementInput" | undefined;
}, {
    path: string;
    type: "Article" | "Core" | "Scope" | "Section" | "TypeSpecification";
    name: string | null;
    id: string;
    components: (ElementComponents & (ArticleComponent | CoreComponent | ScopeComponent | SectionComponent | TypeSpecificationComponent | undefined)) | null;
    __typename?: "AddElementInput" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"MoveElementInput" | undefined, any, "MoveElementInput" | undefined> | undefined;
    id: ZodType<string, any, string>;
    newParentId: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    newParentId: string;
    __typename?: "MoveElementInput" | undefined;
}, {
    id: string;
    newParentId: string;
    __typename?: "MoveElementInput" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"RemoveElementInput" | undefined, any, "RemoveElementInput" | undefined> | undefined;
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    __typename?: "RemoveElementInput" | undefined;
}, {
    id: string;
    __typename?: "RemoveElementInput" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"ReorderElementsInput" | undefined, any, "ReorderElementsInput" | undefined> | undefined;
    order: ZodType<string[], any, string[]>;
    parentElementId: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    order: string[];
    parentElementId: string;
    __typename?: "ReorderElementsInput" | undefined;
}, {
    order: string[];
    parentElementId: string;
    __typename?: "ReorderElementsInput" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"SetRootPathInput" | undefined, any, "SetRootPathInput" | undefined> | undefined;
    newRootPath: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    newRootPath: string;
    __typename?: "SetRootPathInput" | undefined;
}, {
    newRootPath: string;
    __typename?: "SetRootPathInput" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"UpdateElementComponentsInput" | undefined, any, "UpdateElementComponentsInput" | undefined> | undefined;
    components: ZodType<Maybe<ElementComponents>, any, Maybe<ElementComponents>>;
    id: ZodType<string, any, string>;
}>, UnknownKeysParam, ZodTypeAny, {
    id: string;
    components: (ElementComponents & (ArticleComponent | CoreComponent | ScopeComponent | SectionComponent | TypeSpecificationComponent | undefined)) | null;
    __typename?: "UpdateElementComponentsInput" | undefined;
}, {
    id: string;
    components: (ElementComponents & (ArticleComponent | CoreComponent | ScopeComponent | SectionComponent | TypeSpecificationComponent | undefined)) | null;
    __typename?: "UpdateElementComponentsInput" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"UpdateElementNameInput" | undefined, any, "UpdateElementNameInput" | undefined> | undefined;
    id: ZodType<string, any, string>;
    name: ZodType<Maybe<string>, any, Maybe<string>>;
}>, UnknownKeysParam, ZodTypeAny, {
    name: string | null;
    id: string;
    __typename?: "UpdateElementNameInput" | undefined;
}, {
    name: string | null;
    id: string;
    __typename?: "UpdateElementNameInput" | undefined;
}>, ZodObject<Required<{
    __typename?: ZodType<"UpdateElementTypeInput" | undefined, any, "UpdateElementTypeInput" | undefined> | undefined;
    id: ZodType<string, any, string>;
    type: ZodType<ScopeFrameworkElementType, any, ScopeFrameworkElementType>;
}>, UnknownKeysParam, ZodTypeAny, {
    type: "Article" | "Core" | "Scope" | "Section" | "TypeSpecification";
    id: string;
    __typename?: "UpdateElementTypeInput" | undefined;
}, {
    type: "Article" | "Core" | "Scope" | "Section" | "TypeSpecification";
    id: string;
    __typename?: "UpdateElementTypeInput" | undefined;
}>]>;
declare function ScopeFrameworkStateSchema(): ZodObject<Properties<ScopeFrameworkState>>;
declare function SectionComponentSchema(): ZodObject<Properties<SectionComponent>>;
declare function SetRootPathInputSchema(): ZodObject<Properties<SetRootPathInput>>;
declare function TypeSpecificationComponentSchema(): ZodObject<Properties<TypeSpecificationComponent>>;
declare const TypeSpecificationComponentCategorySchema: ZodEnum<["Accessory", "Immutable", "Primary", "Supporting"]>;
declare function UpdateElementComponentsInputSchema(): ZodObject<Properties<UpdateElementComponentsInput>>;
declare function UpdateElementNameInputSchema(): ZodObject<Properties<UpdateElementNameInput>>;
declare function UpdateElementTypeInputSchema(): ZodObject<Properties<UpdateElementTypeInput>>;

declare const zod_d_AddElementInputSchema: typeof AddElementInputSchema;
declare const zod_d_ArticleComponentSchema: typeof ArticleComponentSchema;
declare const zod_d_CoreComponentSchema: typeof CoreComponentSchema;
declare const zod_d_ElementComponentsSchema: typeof ElementComponentsSchema;
declare const zod_d_MoveElementInputSchema: typeof MoveElementInputSchema;
declare const zod_d_RemoveElementInputSchema: typeof RemoveElementInputSchema;
declare const zod_d_ReorderElementsInputSchema: typeof ReorderElementsInputSchema;
declare const zod_d_ScopeComponentSchema: typeof ScopeComponentSchema;
declare const zod_d_ScopeFrameworkElementSchema: typeof ScopeFrameworkElementSchema;
declare const zod_d_ScopeFrameworkElementTypeSchema: typeof ScopeFrameworkElementTypeSchema;
declare const zod_d_ScopeFrameworkInputSchema: typeof ScopeFrameworkInputSchema;
declare const zod_d_ScopeFrameworkStateSchema: typeof ScopeFrameworkStateSchema;
declare const zod_d_SectionComponentSchema: typeof SectionComponentSchema;
declare const zod_d_SetRootPathInputSchema: typeof SetRootPathInputSchema;
declare const zod_d_TypeSpecificationComponentCategorySchema: typeof TypeSpecificationComponentCategorySchema;
declare const zod_d_TypeSpecificationComponentSchema: typeof TypeSpecificationComponentSchema;
declare const zod_d_UpdateElementComponentsInputSchema: typeof UpdateElementComponentsInputSchema;
declare const zod_d_UpdateElementNameInputSchema: typeof UpdateElementNameInputSchema;
declare const zod_d_UpdateElementTypeInputSchema: typeof UpdateElementTypeInputSchema;
declare const zod_d_definedNonNullAnySchema: typeof definedNonNullAnySchema;
declare const zod_d_isDefinedNonNullAny: typeof isDefinedNonNullAny;
declare namespace zod_d {
  export {
    zod_d_AddElementInputSchema as AddElementInputSchema,
    zod_d_ArticleComponentSchema as ArticleComponentSchema,
    zod_d_CoreComponentSchema as CoreComponentSchema,
    zod_d_ElementComponentsSchema as ElementComponentsSchema,
    zod_d_MoveElementInputSchema as MoveElementInputSchema,
    zod_d_RemoveElementInputSchema as RemoveElementInputSchema,
    zod_d_ReorderElementsInputSchema as ReorderElementsInputSchema,
    zod_d_ScopeComponentSchema as ScopeComponentSchema,
    zod_d_ScopeFrameworkElementSchema as ScopeFrameworkElementSchema,
    zod_d_ScopeFrameworkElementTypeSchema as ScopeFrameworkElementTypeSchema,
    zod_d_ScopeFrameworkInputSchema as ScopeFrameworkInputSchema,
    zod_d_ScopeFrameworkStateSchema as ScopeFrameworkStateSchema,
    zod_d_SectionComponentSchema as SectionComponentSchema,
    zod_d_SetRootPathInputSchema as SetRootPathInputSchema,
    zod_d_TypeSpecificationComponentCategorySchema as TypeSpecificationComponentCategorySchema,
    zod_d_TypeSpecificationComponentSchema as TypeSpecificationComponentSchema,
    zod_d_UpdateElementComponentsInputSchema as UpdateElementComponentsInputSchema,
    zod_d_UpdateElementNameInputSchema as UpdateElementNameInputSchema,
    zod_d_UpdateElementTypeInputSchema as UpdateElementTypeInputSchema,
    zod_d_definedNonNullAnySchema as definedNonNullAnySchema,
    zod_d_isDefinedNonNullAny as isDefinedNonNullAny,
  };
}

type index_d_AddElementInput = AddElementInput;
type index_d_ArticleComponent = ArticleComponent;
type index_d_CoreComponent = CoreComponent;
type index_d_ElementComponents = ElementComponents;
type index_d_Exact<T extends {
    [key: string]: unknown;
}> = Exact<T>;
type index_d_InputMaybe<T> = InputMaybe<T>;
type index_d_MakeMaybe<T, K extends keyof T> = MakeMaybe<T, K>;
type index_d_MakeOptional<T, K extends keyof T> = MakeOptional<T, K>;
type index_d_Maybe<T> = Maybe<T>;
type index_d_MoveElementInput = MoveElementInput;
type index_d_Mutation = Mutation;
type index_d_MutationAddElementArgs = MutationAddElementArgs;
type index_d_MutationMoveElementArgs = MutationMoveElementArgs;
type index_d_MutationRemoveElementArgs = MutationRemoveElementArgs;
type index_d_MutationReorderElementsArgs = MutationReorderElementsArgs;
type index_d_MutationSetRootPathArgs = MutationSetRootPathArgs;
type index_d_MutationUpdateElementComponentsArgs = MutationUpdateElementComponentsArgs;
type index_d_MutationUpdateElementNameArgs = MutationUpdateElementNameArgs;
type index_d_MutationUpdateElementTypeArgs = MutationUpdateElementTypeArgs;
type index_d_RemoveElementInput = RemoveElementInput;
type index_d_ReorderElementsInput = ReorderElementsInput;
type index_d_Scalars = Scalars;
type index_d_ScopeComponent = ScopeComponent;
type index_d_ScopeFrameworkElement = ScopeFrameworkElement;
type index_d_ScopeFrameworkElementType = ScopeFrameworkElementType;
type index_d_ScopeFrameworkInput = ScopeFrameworkInput;
type index_d_ScopeFrameworkState = ScopeFrameworkState;
type index_d_SectionComponent = SectionComponent;
type index_d_SetRootPathInput = SetRootPathInput;
type index_d_TypeSpecificationComponent = TypeSpecificationComponent;
type index_d_TypeSpecificationComponentCategory = TypeSpecificationComponentCategory;
type index_d_UpdateElementComponentsInput = UpdateElementComponentsInput;
type index_d_UpdateElementNameInput = UpdateElementNameInput;
type index_d_UpdateElementTypeInput = UpdateElementTypeInput;
declare namespace index_d {
  export {
    index_d_AddElementInput as AddElementInput,
    index_d_ArticleComponent as ArticleComponent,
    index_d_CoreComponent as CoreComponent,
    index_d_ElementComponents as ElementComponents,
    index_d_Exact as Exact,
    index_d_InputMaybe as InputMaybe,
    index_d_MakeMaybe as MakeMaybe,
    index_d_MakeOptional as MakeOptional,
    index_d_Maybe as Maybe,
    index_d_MoveElementInput as MoveElementInput,
    index_d_Mutation as Mutation,
    index_d_MutationAddElementArgs as MutationAddElementArgs,
    index_d_MutationMoveElementArgs as MutationMoveElementArgs,
    index_d_MutationRemoveElementArgs as MutationRemoveElementArgs,
    index_d_MutationReorderElementsArgs as MutationReorderElementsArgs,
    index_d_MutationSetRootPathArgs as MutationSetRootPathArgs,
    index_d_MutationUpdateElementComponentsArgs as MutationUpdateElementComponentsArgs,
    index_d_MutationUpdateElementNameArgs as MutationUpdateElementNameArgs,
    index_d_MutationUpdateElementTypeArgs as MutationUpdateElementTypeArgs,
    index_d_RemoveElementInput as RemoveElementInput,
    index_d_ReorderElementsInput as ReorderElementsInput,
    index_d_Scalars as Scalars,
    index_d_ScopeComponent as ScopeComponent,
    index_d_ScopeFrameworkElement as ScopeFrameworkElement,
    index_d_ScopeFrameworkElementType as ScopeFrameworkElementType,
    index_d_ScopeFrameworkInput as ScopeFrameworkInput,
    index_d_ScopeFrameworkState as ScopeFrameworkState,
    index_d_SectionComponent as SectionComponent,
    index_d_SetRootPathInput as SetRootPathInput,
    index_d_TypeSpecificationComponent as TypeSpecificationComponent,
    index_d_TypeSpecificationComponentCategory as TypeSpecificationComponentCategory,
    index_d_UpdateElementComponentsInput as UpdateElementComponentsInput,
    index_d_UpdateElementNameInput as UpdateElementNameInput,
    index_d_UpdateElementTypeInput as UpdateElementTypeInput,
    zod_d as z,
  };
}

type SetRootPathAction = Action<'SET_ROOT_PATH', SetRootPathInput>;
type AddElementAction = Action<'ADD_ELEMENT', AddElementInput>;
type UpdateElementTypeAction = Action<'UPDATE_ELEMENT_TYPE', UpdateElementTypeInput>;
type UpdateElementNameAction = Action<'UPDATE_ELEMENT_NAME', UpdateElementNameInput>;
type UpdateElementComponentsAction = Action<'UPDATE_ELEMENT_COMPONENTS', UpdateElementComponentsInput>;
type RemoveElementAction = Action<'REMOVE_ELEMENT', RemoveElementInput>;
type ReorderElementsAction = Action<'REORDER_ELEMENTS', ReorderElementsInput>;
type MoveElementAction = Action<'MOVE_ELEMENT', MoveElementInput>;
type ScopeFrameworkMainAction = SetRootPathAction | AddElementAction | UpdateElementTypeAction | UpdateElementNameAction | UpdateElementComponentsAction | RemoveElementAction | ReorderElementsAction | MoveElementAction;

type ScopeFrameworkAction = ScopeFrameworkMainAction;

type ExtendedScopeFrameworkState = Document<ScopeFrameworkState, ScopeFrameworkAction>;

declare class ScopeFramework_Main extends BaseDocument<ScopeFrameworkState, ScopeFrameworkAction> {
    setRootPath(input: SetRootPathInput): this;
    addElement(input: Omit<AddElementInput, "id">): this;
    updateElementType(input: UpdateElementTypeInput): this;
    updateElementName(input: UpdateElementNameInput): this;
    updateElementComponents(input: UpdateElementComponentsInput): this;
    removeElement(input: RemoveElementInput): this;
    reorderElements(input: ReorderElementsInput): this;
    moveElement(input: MoveElementInput): this;
}

interface ScopeFramework$2 extends ScopeFramework_Main {
}
declare class ScopeFramework$2 extends BaseDocument<ScopeFrameworkState, ScopeFrameworkAction> {
    static fileExtension: string;
    get state(): ScopeFrameworkState;
    constructor(initialState?: ExtendedScopeFrameworkState);
    saveToFile(path: string, name?: string): Promise<string>;
    loadFromFile(path: string): Promise<void>;
    static fromFile(path: string): Promise<ScopeFramework$2>;
}

declare const reducer: (state: Document<ScopeFrameworkState, ScopeFrameworkMainAction | BaseAction>, action: ScopeFrameworkMainAction | BaseAction) => Document<ScopeFrameworkState, ScopeFrameworkMainAction>;

declare const createEmptyScopeFrameworkState: () => ScopeFrameworkState;
declare const createEmptyExtendedScopeFrameworkState: () => ExtendedScopeFrameworkState;
declare const loadScopeFrameworkFromFile: (path: string) => Promise<Document<ScopeFrameworkState, ScopeFrameworkMainAction | BaseAction>>;
declare const loadScopeFrameworkFromInput: (input: FileInput) => Promise<ExtendedScopeFrameworkState>;
declare const saveScopeFrameworkToFile: (document: ExtendedScopeFrameworkState, path: string, name?: string) => Promise<string>;
declare const saveScopeFrameworkToFileHandle: (document: ExtendedScopeFrameworkState, input: FileSystemFileHandle) => Promise<void>;

declare const ScopeFramework: typeof ScopeFramework$2;
declare const actions: {
    setRootPath: (input: SetRootPathInput) => SetRootPathAction;
    addElement: (input: Omit<AddElementInput, "id">) => AddElementAction;
    updateElementType: (input: UpdateElementTypeInput) => UpdateElementTypeAction;
    updateElementName: (input: UpdateElementNameInput) => UpdateElementNameAction;
    updateElementComponents: (input: UpdateElementComponentsInput) => UpdateElementComponentsAction;
    removeElement: (input: RemoveElementInput) => RemoveElementAction;
    reorderElements: (input: ReorderElementsInput) => ReorderElementsAction;
    moveElement: (input: MoveElementInput) => MoveElementAction;
    setName: (name: string) => SetNameAction;
    undo: (count?: number) => UndoAction;
    redo: (count?: number) => RedoAction;
    prune: (start?: number | undefined, end?: number | undefined) => PruneAction;
    loadState: (state: Pick<Document<unknown, Action<string, unknown>>, "name" | "data">, operations: number) => LoadStateAction;
};

type ScopeFramework$1_ExtendedScopeFrameworkState = ExtendedScopeFrameworkState;
declare const ScopeFramework$1_ScopeFramework: typeof ScopeFramework;
type ScopeFramework$1_ScopeFrameworkAction = ScopeFrameworkAction;
type ScopeFramework$1_ScopeFrameworkState = ScopeFrameworkState;
declare const ScopeFramework$1_actions: typeof actions;
declare const ScopeFramework$1_createEmptyExtendedScopeFrameworkState: typeof createEmptyExtendedScopeFrameworkState;
declare const ScopeFramework$1_createEmptyScopeFrameworkState: typeof createEmptyScopeFrameworkState;
declare const ScopeFramework$1_loadScopeFrameworkFromFile: typeof loadScopeFrameworkFromFile;
declare const ScopeFramework$1_loadScopeFrameworkFromInput: typeof loadScopeFrameworkFromInput;
declare const ScopeFramework$1_reducer: typeof reducer;
declare const ScopeFramework$1_saveScopeFrameworkToFile: typeof saveScopeFrameworkToFile;
declare const ScopeFramework$1_saveScopeFrameworkToFileHandle: typeof saveScopeFrameworkToFileHandle;
declare namespace ScopeFramework$1 {
  export {
    ScopeFramework$1_ExtendedScopeFrameworkState as ExtendedScopeFrameworkState,
    ScopeFramework$1_ScopeFramework as ScopeFramework,
    ScopeFramework$1_ScopeFrameworkAction as ScopeFrameworkAction,
    ScopeFramework$1_ScopeFrameworkState as ScopeFrameworkState,
    ScopeFramework$1_actions as actions,
    ScopeFramework$1_createEmptyExtendedScopeFrameworkState as createEmptyExtendedScopeFrameworkState,
    ScopeFramework$1_createEmptyScopeFrameworkState as createEmptyScopeFrameworkState,
    ScopeFramework$1_loadScopeFrameworkFromFile as loadScopeFrameworkFromFile,
    ScopeFramework$1_loadScopeFrameworkFromInput as loadScopeFrameworkFromInput,
    ScopeFramework$1_reducer as reducer,
    ScopeFramework$1_saveScopeFrameworkToFile as saveScopeFrameworkToFile,
    ScopeFramework$1_saveScopeFrameworkToFileHandle as saveScopeFrameworkToFileHandle,
    index_d as types,
  };
}

export { ExtendedScopeFrameworkState as E, ScopeFramework$1 as S, actions as a, ScopeFramework as b, ScopeFrameworkAction as c, ScopeFrameworkState as d, createEmptyScopeFrameworkState as e, createEmptyExtendedScopeFrameworkState as f, loadScopeFrameworkFromInput as g, saveScopeFrameworkToFileHandle as h, index_d as i, loadScopeFrameworkFromFile as l, reducer as r, saveScopeFrameworkToFile as s };
