@elyx-code/project-logic-tree 0.0.6996 → 0.0.7000

package/dist/tree/state/change-set/change-set.d.ts

@@ -0,0 +1,483 @@
+import { EntityId, EntityType, UserManagedElementShallowTransfer } from '../../../definitions';
+import { UserManagedEntityState } from '../types';
+import { ProjectState } from '../project';
+import { LoggerInstance, YieldOptions, Events } from '@elyx-code/common-ts-utils';
+import { BuiltInBaseEntityState } from '../built-in-base-entity';
+import { PrimitiveEntityState } from '../primitive-entity';
+import { EntityErrorCode, EntityGenerationErrorCode, SharedEntityErrorCode } from '../error';
+
+export declare enum ChangeSetChangeCaptureType {
+    Manual = "manual",
+    Automatic = "automatic"
+}
+export declare enum ChangeSetEntityChangeType {
+    Added = "added",
+    Updated = "updated",
+    Removed = "removed",
+    Affected = "affected"
+}
+export declare enum StateMutationAction {
+    AddSuccessCall = "add-success-call",
+    AddErrorCall = "add-error-call",
+    AddCall = "add-call",
+    SetParent = "set-parent",
+    SetStandaloneParent = "set-standalone-parent",
+    AfterAllChildrenInitialized = "after-all-children-initialized",
+    UpdateWithShallowTransfer = "update-with-shallow-transfer",
+    UpdateWithGenerationTarget = "update-with-generation-target",
+    RemoveFromParent = "remove-from-parent",
+    RemoveEntity = "remove-entity",
+    RestoreEntity = "restore-entity",
+    CloneEntity = "clone-entity",
+    AddInput = "add-input",
+    RemoveInput = "remove-input",
+    SetDataType = "set-data-type",
+    RemoveDataType = "remove-data-type",
+    SetAdditionalPropertiesDataType = "set-additional-properties-data-type",
+    RemoveAdditionalPropertiesDataType = "remove-additional-properties-data-type",
+    SetAllPropertiesImplement = "set-all-properties-implement",
+    RemoveAllPropertiesImplement = "remove-all-properties-implement",
+    RemoveValueReader = "remove-value-reader",
+    AddValueReader = "add-value-reader",
+    RemoveValueWriter = "remove-value-writer",
+    SetValueWriter = "set-value-writer",
+    AddEntryCaller = "add-entry-caller",
+    AddSuccessCaller = "add-success-caller",
+    AddErrorCaller = "add-error-caller",
+    RemoveCall = "remove-call",
+    RemoveCaller = "remove-caller",
+    RemoveChildGroup = "remove-child-group",
+    AddToAndGroup = "add-to-and-group",
+    AddToOrGroup = "add-to-or-group",
+    RemoveUnrecognizedInputs = "remove-unrecognized-inputs",
+    RemoveUnrecognizedOutputs = "remove-unrecognized-outputs",
+    SyncInputs = "sync-inputs",
+    SyncOutputs = "sync-outputs",
+    SetImplements = "set-implements",
+    SetExtends = "set-extends",
+    SetExtension = "set-extension",
+    AddImplementation = "add-implementation",
+    RemoveImplementation = "remove-implementation",
+    AddProperty = "add-property",
+    RemoveProperty = "remove-property",
+    AddMethod = "add-method",
+    RemoveMethod = "remove-method",
+    AddAbstractMethod = "add-abstract-method",
+    RemoveAbstractMethod = "remove-abstract-method",
+    SetValueAsTypeSingle = "set-value-as-type-single",
+    SetValueAsTypeList = "set-value-as-type-list",
+    SetValueAsType = "set-value-as-type",
+    RemoveErrorCatching = "remove-error-catching",
+    RemoveAllErrorCallers = "remove-all-error-callers",
+    RemoveAllSuccessCallers = "remove-all-success-callers",
+    RemoveAllCallers = "remove-all-callers",
+    RemoveAllErrorCalls = "remove-all-error-calls",
+    SetDataTypeEntityValue = "set-data-type-entity-value",
+    MergeDataTypes = "merge-data-types",
+    SetDataTypeForeignKeyRef = "set-data-type-foreign-key-ref",
+    SetErrorEntity = "set-error-entity",
+    AddValueAsTypeToList = "add-value-as-type-to-list",
+    RemoveValueAsTypeFromList = "remove-value-as-type-from-list",
+    CreateFromGenerationTarget = "create-from-generation-target",
+    ConnectExternalAccount = "connect-external-account",
+    ChangeExternalAccountConnectionUsed = "change-external-account-connection-used",
+    MoveInlineDefToCanvas = "move-inline-def-to-canvas",
+    CreateDefFromValue = "create-def-from-value",
+    PrettifyCanvas = "prettify-canvas",
+    SetPrimitiveDefaultValue = "set-primitive-default-value",
+    MakeArgRequired = "make-argument-required",
+    MakeArgNonRequired = "make-argument-non-required",
+    RecalculateArg = "recalculate-arg",
+    RenameArg = "rename-argument",
+    ChangeArgDescription = "changed-argument-description",
+    RemoveArgBaseImplementation = "remove-argument-base-implementation",
+    AddArgBaseImplementation = "add-argument-base-implementation",
+    ChangeArgDataType = "change-argument-data-type",
+    RecalculateCondition = "recalculate-condition",
+    ChangeTypeOfCondition = "change-type-of-condition",
+    RenameDefinition = "rename-definition",
+    RecalculateDef = "recalculate-definition",
+    ChangeDefDescription = "changed-definition-description",
+    RemoveDefBaseImplementation = "remove-definition-base-implementation",
+    AddDefBaseImplementation = "add-definition-base-implementation",
+    RemoveDefExtension = "remove-definition-extension",
+    SetDefExtends = "set-definition-extension",
+    MakeDefStatic = "make-def-static",
+    MakeDefNonStatic = "make-def-non-static",
+    MakeDefAbstract = "make-def-abstract",
+    MakeDefNonAbstract = "make-def-non-abstract",
+    RecalculateFuncCall = "recalculate-function-call",
+    ChangeFuncCallDeclaration = "change-function-call-declaration",
+    RenameFuncDecl = "rename-function-declaration",
+    ChangeFuncDeclDescription = "changed-function-declaration-description",
+    RecalculateFuncDecl = "recalculate-function-declaration",
+    SetFuncDeclBaseImplementation = "set-function-declaration-base-implementation",
+    ChangeFuncDeclOutputDataType = "change-function-declaration-output-data-type",
+    RecalculateGlobalEvent = "recalculate-global-event",
+    ChangeGlobalEventDescription = "changed-global-event-description",
+    ChangeGlobalEventType = "changed-global-event-type",
+    RecalculateInputMap = "recalculate-input",
+    ChangeInputMapDescription = "changed-input-description",
+    ChangeInputMapDataType = "change-input-data-type",
+    RecalculateLoop = "recalculate-loop",
+    ChangeLoopType = "changed-loop-type",
+    ChangeLoopOutputDataType = "change-loop-output-data-type",
+    RecalculateOperation = "recalculate-operation",
+    ChangeOperationType = "changed-operation-type",
+    RecalculateOutputMap = "recalculate-output",
+    ChangeOutputMapDataType = "change-output-data-type",
+    RecalculateProperty = "recalculate-property",
+    MakePropertyRequired = "make-property-required",
+    MakePropertyNonRequired = "make-property-non-required",
+    MakePropertyConstant = "make-property-constant",
+    MakePropertyNonConstant = "make-property-non-constant",
+    MakePropertyUnique = "make-property-unique",
+    MakePropertyNonUnique = "make-property-non-unique",
+    MakePropertyStatic = "make-property-static",
+    MakePropertyNonStatic = "make-property-non-static",
+    MakePropertyAbstract = "make-property-abstract",
+    MakePropertyNonAbstract = "make-property-non-abstract",
+    RenameProperty = "rename-property",
+    ChangePropertyDescription = "changed-property-description",
+    RemovePropertyBaseImplementation = "remove-property-base-implementation",
+    AddPropertyBaseImplementation = "add-property-base-implementation",
+    ChangePropertyDataType = "change-property-data-type",
+    RecalculateSearch = "recalculate-search",
+    RenameSearch = "rename-search",
+    ChangeSearchDescription = "changed-search-description",
+    ChangeSearchQuery = "changed-search-query",
+    MakeValueDescriptorRequired = "make-value-descriptor-required",
+    MakeSearchInputRequired = "make-search-input-required",
+    MakeValueDescriptorNonRequired = "make-value-descriptor-non-required",
+    MakeSearchInputNonRequired = "make-search-input-non-required",
+    RenameValueDescriptor = "rename-value-descriptor",
+    RenameSearchInput = "rename-search-input",
+    ChangeValueDescriptorDescription = "changed-value-descriptor-description",
+    ChangeSearchInputDescription = "changed-search-input-description",
+    ChangeValueDescriptorDataType = "change-value-descriptor-data-type",
+    RecalculateVarDecl = "recalculate-variable-declaration",
+    MakeVarDeclConstant = "make-variable-declaration-constant",
+    MakeVarDeclNonConstant = "make-variable-declaration-non-constant",
+    RenameVarDecl = "rename-variable-declaration",
+    ChangeVarDeclDescription = "changed-variable-declaration-description",
+    ChangeVarDeclDataType = "change-variable-declaration-data-type",
+    RecalculateVarInst = "recalculate-variable-instance",
+    ChangeVarInstDeclaration = "change-variable-instance-declaration",
+    HideFuncDeclBody = "hide-function-declaration-body",
+    ShowFuncDeclBody = "show-function-declaration-body",
+    HideGlobalEventBody = "hide-global-event-body",
+    ShowGlobalEventBody = "show-global-event-body",
+    HideLoopBody = "hide-loop-body",
+    ShowLoopBody = "show-loop-body",
+    HideTriggerBody = "hide-trigger-body",
+    ShowTriggerBody = "show-trigger-body",
+    AddNestedAndCondition = "add-nested-and-condition",
+    AddInputToCondition = "add-input-to-condition",
+    RecalculateNode = "recalculate-node",
+    AddInputToFuncDecl = "add-input-to-function-declaration",
+    ChangeInternalCallToThrowErrors = "change-internal-call-to-throw-errors",
+    ChangeInternalCallToCatchErrors = "change-internal-call-to-catch-errors",
+    AddErrorOutputToInternalCall = "add-error-output-to-internal-call",
+    ChangeLoopToThrowErrors = "change-loop-to-throw-errors",
+    ChangeLoopToCatchErrors = "change-loop-to-catch-errors",
+    RecalculateLoopBody = "recalculate-loop-body",
+    RecalculateMethod = "recalculate-method",
+    AddArgToLoopBody = "add-arg-to-loop-body",
+    AddArgToMethod = "add-arg-to-method",
+    RecalculateNestedCondition = "recalculate-nested-condition",
+    ChangeNodeToThrowErrors = "change-node-to-throw-errors",
+    ChangeNodeToCatchErrors = "change-node-to-catch-errors",
+    ChangeOperationToThrowErrors = "change-operation-to-throw-errors",
+    ChangeOperationToCatchErrors = "change-operation-to-catch-errors",
+    ChangeFuncCallToThrowErrors = "change-function-call-to-throw-errors",
+    ChangeFuncCallToCatchErrors = "change-function-call-to-catch-errors",
+    ChangeSearchToThrowErrors = "change-search-to-throw-errors",
+    ChangeSearchToCatchErrors = "change-search-to-catch-errors",
+    ChangeVarDeclToThrowErrors = "change-variable-declaration-to-throw-errors",
+    ChangeVarDeclToCatchErrors = "change-variable-declaration-to-catch-errors",
+    ChangeVarInstToThrowErrors = "change-variable-instance-to-throw-errors",
+    ChangeVarInstToCatchErrors = "change-variable-instance-to-catch-errors",
+    AddErrorOutputToNode = "add-error-output-to-node",
+    AddErrorOutputToOperation = "add-error-output-to-operation",
+    AddErrorOutputToFuncCall = "add-error-output-to-function-call",
+    AddErrorOutputToSearch = "add-error-output-to-search",
+    AddErrorOutputToVarDecl = "add-error-output-to-variable-declaration",
+    AddErrorOutputToVarInst = "add-error-output-to-variable-instance",
+    AddInputToNode = "add-input-to-node",
+    AddInputToOperation = "add-input-to-operation",
+    AddInputToFuncCall = "add-input-to-function-call",
+    AddInputToSearch = "add-input-to-search",
+    AddPropertyToVarDecl = "add-property-to-variable-declaration",
+    AddPropertyToVarInst = "add-property-to-variable-instance",
+    AddMethodToDef = "add-method-to-definition",
+    ReSyncRowTransformer = "re-sync-row-transformer",
+    ManuallyAddRowTransformer = "manually-add-row-transformer",
+    AddPropertyToDef = "add-property-to-definition",
+    RestablishExternalAccountConnection = "restablish-external-account-connection",
+    AddThrownError = "add-thrown-error",
+    RecalculateTerminationStatement = "recalculate-termination-statement",
+    RecalculateReturnStmt = "recalculate-return-statement",
+    RecalculateContinueStmt = "recalculate-continue-statement",
+    RecalculateBreakStmt = "recalculate-break-statement",
+    AddPropertyToTerminationStatement = "add-property-to-termination-statement",
+    AddPropertyToReturnStmt = "add-property-to-return-statement",
+    AddPropertyToContinueStmt = "add-property-to-continue-statement",
+    AddPropertyToBreakStmt = "add-property-to-break-statement",
+    SetLiteralValueToExplicitlyEmpty = "set-literal-value-to-explicitly-empty",
+    ModifyLiteralValue = "modify-literal-value",
+    RemoveLiteralValue = "remove-literal-value",
+    ModifyLiteralValueAsType = "modify-literal-value-as-type",
+    UpdateProjectMetadata = "update-project-metadata",
+    RenameProject = "rename-project",
+    ChangeProjectDescription = "change-project-description",
+    RestoreNode = "restore-node",
+    RestoreDef = "restore-definition",
+    RestoreFuncDecl = "restore-function-declaration",
+    RestoreGlobalEvent = "restore-global-event",
+    RestoreSearch = "restore-search",
+    RestoreVarDecl = "restore-variable-declaration",
+    RestoreVarInst = "restore-variable-instance",
+    RestoreFuncCall = "restore-function-call",
+    RestoreOperation = "restore-operation",
+    RestoreCondition = "restore-condition",
+    RestoreReturnStmt = "restore-return-statement",
+    RestoreContinueStmt = "restore-continue-statement",
+    RestoreBreakStmt = "restore-break-statement",
+    RestoreInstalledProject = "restore-installed-project",
+    RestoreLoop = "restore-loop",
+    CreateNewDef = "create-new-definition",
+    CreateNewFuncDecl = "create-new-function-declaration",
+    CreateNewGlobalEvent = "create-new-global-event",
+    CreateNewSearch = "create-new-search",
+    CreateNewVarDecl = "create-new-variable-declaration",
+    CreateNewVarInst = "create-new-variable-instance",
+    CreateNewFuncCall = "create-new-function-call",
+    CreateNewOperation = "create-new-operation",
+    CreateNewCondition = "create-new-condition",
+    CreateNewReturnStmt = "create-new-return-statement",
+    CreateNewContinueStmt = "create-new-continue-statement",
+    CreateNewBreakStmt = "create-new-break-statement",
+    CreateNewInternalCall = "create-new-internal-call",
+    CreateNewLoop = "create-new-loop",
+    ImplementBuiltInFunctionalityAsDef = "implement-built-in-functionality-as-definition",
+    ImplementAbstractEntityAsDef = "implement-abstract-entity-as-definition",
+    ImplementNewHTTPEndpoint = "implement-new-http-endpoint",
+    ImplementNewScheduledTrigger = "implement-new-scheduled-trigger",
+    ImplementNewPersistedEntity = "implement-new-persisted-entity",
+    AddedNewRowTransformer = "added-new-row-transformer",
+    AddedSQLConnectionConfig = "added-sql-connection-config",
+    AddedNewSSLConnectionConfig = "added-new-ssl-connection-config",
+    AddedGoogleConnection = "added-google-connection",
+    AddedSlackConnection = "added-slack-connection",
+    AddedNewExternalAccountConnection = "added-new-external-account-connection",
+    AddedGoogleDriveConnection = "added-google-drive-connection",
+    AddedGoogleSheetsConnection = "added-google-sheets-connection",
+    AddedGoogleSlidesConnection = "added-google-slides-connection",
+    AddedGoogleMailConnection = "added-gmail-connection",
+    ManuallyCreateIndividualNode = "manually-create-individual-node",
+    UpdateNode = "update-node",
+    CreateNewProjectPublicationCompletedEvent = "create-new-project-publication-completed-event",
+    CreateNewCountedLoop = "create-new-counted-loop",
+    CreateNewListLoop = "create-new-list-loop",
+    CreateNewManualFlowLoop = "create-new-manual-flow-loop",
+    CreateNewObjectKeysLoop = "create-new-object-keys-loop",
+    CreateNewObjectValuesLoop = "create-new-object-values-loop",
+    CreateNewStringLoop = "create-new-string-loop",
+    CreateNewIsFalseCondition = "create-new-is-false-condition",
+    CreateNewIsTrueCondition = "create-new-is-true-condition",
+    CreateNewAndCondition = "create-new-and-condition",
+    CreateNewOrCondition = "create-new-or-condition",
+    DisconnectNodes = "disconnect-nodes",
+    DisconnectExecutions = "disconnect-executions",
+    DisconnectValues = "disconnect-values",
+    ConnectNodes = "connect-nodes",
+    ConnectExecution = "connect-execution",
+    ConnectValues = "connect-values",
+    ConnectValueToNewInput = "connect-value-to-new-input",
+    ConnectValueToNewOperationInput = "connect-value-to-new-operation-input",
+    ConnectValueToNewConditionInput = "connect-value-to-new-condition-input",
+    ConnectValueToNewSearchInput = "connect-value-to-new-search-input",
+    ConnectValueToNewVarDeclProperty = "connect-value-to-new-variable-declaration-property",
+    ConnectValueToNewVarInstProperty = "connect-value-to-new-variable-instance-property",
+    ConnectValueToNewReturnStmtProperty = "connect-value-to-new-return-statement-property",
+    ConnectValueToNewContinueStmtProperty = "connect-value-to-new-continue-statement-property",
+    ConnectValueToNewBreakStmtProperty = "connect-value-to-new-break-statement-property",
+    ConnectNewFuncDeclArgToValue = "connect-new-function-argument-to-value",
+    RemoveNodes = "remove-nodes",
+    RemoveNode = "remove-node",
+    InitialLoadAutomaticCanvasRefresh = "initial-load-automatic-canvas-refresh",
+    MoveNodes = "move-nodes",
+    MoveNode = "move-node",
+    CloneNodes = "clone-nodes",
+    CloneNode = "clone-node",
+    GenerateSQLMigrationOnPersistedEntityUpdate = "generate-sql-migration-on-persisted-entity-update"
+}
+export declare enum StateMutationErrorCode {
+    ActionOwnerEntityNotEditable = "action-owner-entity-not-editable",
+    ActionCounterpartEntityNotEditable = "action-counterpart-entity-not-editable",
+    ActionOwnerEntityNonDeletable = "action-owner-entity-non-deletable",
+    GlobalVariableDeclarationCannnotCatchError = "global-variable-declaration-cannot-catch-error",
+    GlobalVariableDeclarationCannotReadValue = "global-variable-declaration-cannot-read-value",
+    GlobalVariableDeclarationCannotBeCalled = "global-variable-declaration-cannot-be-called",
+    GlobalVariableDeclarationCannotCallFromError = "global-variable-declaration-cannot-call-from-error",
+    ValueReadingOverridesConstantProperty = "value-reading-overrides-constant-property",
+    DefaultValueOverridesConstantProperty = "default-value-overrides-constant-property",
+    ValueReadingOverridesConstantVariable = "value-reading-overrides-constant-variable",
+    DefaultValueOverridesConstantVariable = "default-value-overrides-constant-variable",
+    CannotSuccessCallItself = "cannot-success-call-itself",
+    CannotErrorCallItself = "cannot-error-call-itself",
+    CannotEntryCallItself = "cannot-entry-call-itself",
+    CannotValueWriteItself = "cannot-value-write-itself",
+    CannotBeCalledBeforeDeclaration = "cannot-be-called-before-declaration",
+    CannotBeCalledInParallelBranchToDeclaration = "cannot-be-called-in-parallel-branch-to-declaration",
+    CannotBeHigherScopeThanDeclaration = "cannot-be-higher-scope-than-declaration",
+    InputsInGlobalVariableDeclarationsCannotReadValues = "inputs-in-global-variable-declarations-cannot-read-values"
+}
+export interface IChangeSet<TSelf extends {
+    id: string;
+    type: EntityType;
+} | null = UserManagedEntityState, TGeneric extends {
+    id: string;
+    type: EntityType;
+} = UserManagedEntityState> {
+    added: TGeneric[];
+    updated: TGeneric[];
+    removed: TGeneric[];
+    affected: TGeneric[];
+    self: TSelf;
+    actionName?: StateMutationAction | string;
+}
+export interface IRecordChangeSet<TSelf extends {
+    id: string;
+    type: EntityType;
+} | null = UserManagedElementShallowTransfer, TGeneric extends {
+    id: string;
+    type: EntityType;
+} = UserManagedElementShallowTransfer> {
+    added: Record<EntityId, TGeneric>;
+    updated: Record<EntityId, TGeneric>;
+    removed: Record<EntityId, TGeneric>;
+    affected: EntityId[];
+    self: TSelf;
+    seenEntities: EntityId[];
+    actionName?: StateMutationAction | string;
+}
+export interface IChangeSetStorageFormat {
+    id: string;
+    author: string;
+    timestamp: string;
+    dirty: boolean;
+    project: string;
+    version: string;
+    previousVersion: string;
+    branch: string;
+    added: Record<EntityId, UserManagedElementShallowTransfer>;
+    updated: Record<EntityId, UserManagedElementShallowTransfer>;
+    removed: Record<EntityId, UserManagedElementShallowTransfer>;
+    affected: EntityId[];
+    actionName?: StateMutationAction | string;
+    self: EntityId;
+}
+export interface IChangeSetEvent {
+    id: string;
+    action: StateMutationAction;
+    errorReason: StateMutationErrorCode | EntityErrorCode | SharedEntityErrorCode | EntityGenerationErrorCode | null;
+    owner: UserManagedEntityState | null;
+    counterpart: UserManagedEntityState | PrimitiveEntityState | BuiltInBaseEntityState | null;
+    rootAction: boolean;
+}
+export interface IChangeSetEventCreationPayload {
+    id: string;
+    action: StateMutationAction;
+    errorReason?: StateMutationErrorCode;
+    owner?: UserManagedEntityState;
+    counterpart?: UserManagedEntityState | PrimitiveEntityState | BuiltInBaseEntityState;
+    rootAction?: boolean;
+}
+export declare class ChangeSetEvent implements IChangeSetEvent {
+    id: string;
+    action: StateMutationAction;
+    errorReason: StateMutationErrorCode | null;
+    owner: UserManagedEntityState | null;
+    counterpart: UserManagedEntityState | PrimitiveEntityState | BuiltInBaseEntityState | null;
+    rootAction: boolean;
+    parent: ChangeSet;
+    constructor({ id, action, errorReason, owner, counterpart, rootAction }: IChangeSetEventCreationPayload, changeSet: ChangeSet);
+}
+export declare class ChangeSet extends Events {
+    id: string;
+    seenEntities: EntityId[];
+    added: Record<EntityId, UserManagedEntityState>;
+    updated: Record<EntityId, UserManagedEntityState>;
+    removed: Record<EntityId, UserManagedEntityState>;
+    affected: Record<EntityId, UserManagedEntityState>;
+    self: UserManagedEntityState | null;
+    author: string;
+    timestamp: string;
+    open: boolean;
+    startedClose: boolean;
+    dirty: boolean;
+    submitting: boolean;
+    lockedVersions: boolean;
+    type: ChangeSetChangeCaptureType;
+    autoclose: boolean;
+    actionName: string;
+    project: ProjectState;
+    events: Map<string, ChangeSetEvent>;
+    ignoreNonEditable: boolean;
+    ignoreNonDeletable: boolean;
+    logger: LoggerInstance;
+    constructor(project: ProjectState, author: string, timestamp: string, // ISO 8601 format
+    self: UserManagedEntityState | null, autoclose?: boolean, actionName?: string);
+    get index(): number | null;
+    get isEmpty(): boolean;
+    get isValid(): boolean;
+    get list(): UserManagedEntityState[];
+    get listAdded(): UserManagedEntityState[];
+    get listUpdated(): UserManagedEntityState[];
+    get listRemoved(): UserManagedEntityState[];
+    get listAffected(): UserManagedEntityState[];
+    get addedIds(): EntityId[];
+    get updatedIds(): EntityId[];
+    get removedIds(): EntityId[];
+    get affectedIds(): EntityId[];
+    event(payload: IChangeSetEventCreationPayload): void;
+    discardOrphans(): void;
+    discardOrphansAsync(options?: YieldOptions): Promise<void>;
+    captureAllChangesInVersionInstances(): void;
+    captureAllChangesInVersionInstancesAsync(options?: YieldOptions): Promise<void>;
+    attemptAutocloseAsync(knownAutoCloseActionName: string, closingEntityId: EntityId): Promise<ChangeSet>;
+    closeAsync(options?: {
+        awaitBeforeClose?: boolean;
+        awaitExternalPersist?: boolean;
+        persistType?: 'sequential' | 'parallel';
+    } & YieldOptions): Promise<ChangeSet>;
+    attemptAutoclose(knownAutoCloseActionName: string, closingEntityId: EntityId): ChangeSet;
+    recursiveCaptureUpstreamVersions(): void;
+    recursiveCaptureUpstreamVersionsAsync(options?: YieldOptions): Promise<void>;
+    sanitize(): void;
+    sanitizeAsync(options?: YieldOptions): Promise<void>;
+    syncDependents(): ChangeSet;
+    syncDependentsAsync(options?: YieldOptions): Promise<ChangeSet>;
+    beforeCloseAsync(options?: YieldOptions): Promise<void>;
+    beforeClose(): void;
+    teardown(): void;
+    emitProjectSideEffects(): ChangeSet;
+    emitAsyncProjectSideEffects(options?: YieldOptions): Promise<ChangeSet>;
+    close(options?: {
+        persistType?: 'sequential' | 'parallel';
+    }): ChangeSet;
+    addDependentsToAffected(entity: UserManagedEntityState): void;
+    get(entityId: EntityId): UserManagedEntityState | null;
+    remove(entityId: EntityId): ChangeSet;
+    add(entity: UserManagedEntityState, changeType: ChangeSetEntityChangeType, options?: {
+        preventRecursion?: boolean;
+    }): ChangeSet;
+    toJSON(): IRecordChangeSet<UserManagedElementShallowTransfer | null, UserManagedElementShallowTransfer>;
+    has(entityId: EntityId): boolean;
+    hasAdded(entityId: EntityId): boolean;
+    hasUpdated(entityId: EntityId): boolean;
+    hasRemoved(entityId: EntityId): boolean;
+    hasAffected(entityId: EntityId): boolean;
+}
+export declare function changeSetJSONRecordToUniqueIds(changeSet: IRecordChangeSet): Set<EntityId>;

package/dist/tree/state/change-set/change-set.part3.test-process.d.ts

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

package/dist/tree/state/change-set/change-set.part4.test-process.d.ts

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

package/dist/tree/state/change-set/index.d.ts

@@ -0,0 +1,4 @@
+export * from './change-set';
+export * from './side-effect-events';
+export * from './versioning';
+export * from './utils';

package/dist/tree/state/change-set/side-effect-events.d.ts

@@ -0,0 +1,5 @@
+import { ChangeSet } from './change-set';
+import { YieldOptions } from '@elyx-code/common-ts-utils';
+
+export declare function emitProjectSideEffects(changeSet: ChangeSet): ChangeSet;
+export declare function emitAsyncProjectSideEffects(changeSet: ChangeSet, options?: YieldOptions): Promise<ChangeSet>;

package/dist/tree/state/change-set/utils.d.ts

@@ -0,0 +1,23 @@
+import { ChangeSet, IRecordChangeSet } from './change-set';
+import { UserManagedEntityState } from '../types';
+import { EntityId, UserManagedElementShallowTransfer } from '../../../definitions';
+
+export declare function makeAllChangeSetEntitiesEditable(changeSet: ChangeSet): void;
+export declare function makeAllChangeSetEntitiesDeletable(changeSet: ChangeSet): void;
+export declare function makeAllChangeSetEntitiesEditableAndDeletable(changeSet: ChangeSet): void;
+export declare function makeAllChangeSetEntitiesNonEditable(changeSet: ChangeSet): void;
+export declare function makeAllChangeSetEntitiesNonDeletable(changeSet: ChangeSet): void;
+export declare function makeAllChangeSetEntitiesNonEditableAndNonDeletable(changeSet: ChangeSet): void;
+export declare function recursivelyMakeAllNonEditableAndNonDeletableFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet | null): void;
+export declare function recursivelyMakeAllEditableAndDeletableFromGiven(entity: UserManagedEntityState, changeSet: ChangeSet | null): void;
+export declare function applyQueuedToCached(opts: {
+    projectId: EntityId;
+    projectRecord: Record<EntityId, UserManagedElementShallowTransfer>;
+    chain: IRecordChangeSet<UserManagedElementShallowTransfer | null, UserManagedElementShallowTransfer>[];
+    sort?: boolean;
+    order?: boolean;
+}): {
+    project: UserManagedElementShallowTransfer;
+    record: Record<EntityId, UserManagedElementShallowTransfer>;
+    order: EntityId[] | null;
+};

package/dist/tree/state/change-set/versioning.d.ts

@@ -0,0 +1,12 @@
+import { ChangeSet } from './change-set';
+import { ProjectState } from '../project';
+import { UserManagedEntityState } from '../types';
+
+export interface IProjectVersionTransitionConfig {
+    transitionalChangeSet: ChangeSet;
+    transitionTime: string;
+    timeOfOriginalTargetChanges: string;
+}
+export declare function transitionProjectVersion(from: ChangeSet | 'initial', to: ChangeSet | 'initial', project: ProjectState): IProjectVersionTransitionConfig;
+export declare function traverseChangeSet(changeSet: ChangeSet, onAdded: (entity: UserManagedEntityState) => void, onUpdated: (entity: UserManagedEntityState) => void, onRemoved: (entity: UserManagedEntityState) => void, onAffected: (entity: UserManagedEntityState) => void): void;
+export declare function rebaseStack<T = any>(undoableStackValueIndex: number, history: T[], newItem: T): number;