oak-domain 5.1.16 → 5.1.18

package/lib/base-app-domain/EntityDict.d.ts

@@ -1,17 +1,698 @@
-import { EntityDef as ActionAuth } from "./ActionAuth/Schema";
-import { EntityDef as I18n } from "./I18n/Schema";
-import { EntityDef as Log } from "./Log/Schema";
-import { EntityDef as Modi } from "./Modi/Schema";
-import { EntityDef as ModiEntity } from "./ModiEntity/Schema";
-import { EntityDef as Oper } from "./Oper/Schema";
-import { EntityDef as OperEntity } from "./OperEntity/Schema";
-import { EntityDef as Path } from "./Path/Schema";
-import { EntityDef as Relation } from "./Relation/Schema";
-import { EntityDef as RelationAuth } from "./RelationAuth/Schema";
-import { EntityDef as User } from "./User/Schema";
-import { EntityDef as UserEntityClaim } from "./UserEntityClaim/Schema";
-import { EntityDef as UserEntityGrant } from "./UserEntityGrant/Schema";
-import { EntityDef as UserRelation } from "./UserRelation/Schema";
+import { MakeFilter, SubQueryPredicateMetadata } from "../types/Demand";
+import { FormCreateData, FormUpdateData, DeduceAggregation, Operation as OakOperation, Selection as OakSelection, AggregationResult } from "../types/Entity";
+import * as BaseActionAuth from "./ActionAuth/_baseSchema";
+import * as BaseI18n from "./I18n/_baseSchema";
+import * as BaseLog from "./Log/_baseSchema";
+import * as BaseModi from "./Modi/_baseSchema";
+import * as BaseModiEntity from "./ModiEntity/_baseSchema";
+import * as BaseOper from "./Oper/_baseSchema";
+import * as BaseOperEntity from "./OperEntity/_baseSchema";
+import * as BasePath from "./Path/_baseSchema";
+import * as BaseRelation from "./Relation/_baseSchema";
+import * as BaseRelationAuth from "./RelationAuth/_baseSchema";
+import * as BaseUser from "./User/_baseSchema";
+import * as BaseUserEntityClaim from "./UserEntityClaim/_baseSchema";
+import * as BaseUserEntityGrant from "./UserEntityGrant/_baseSchema";
+import * as BaseUserRelation from "./UserRelation/_baseSchema";
+export type ActionAuth = {
+    OpSchema: BaseActionAuth.OpSchema;
+    Action: BaseActionAuth.OpAction;
+    Schema: BaseActionAuth.OpSchema & {
+        relation?: Relation["Schema"];
+        path: Path["Schema"];
+    };
+    Projection: BaseActionAuth.OpProjection & {
+        relation?: Relation["Projection"];
+        path?: Path["Projection"];
+    };
+    FilterUnit: BaseActionAuth.OpFilter & {
+        relation: MakeFilter<Relation["FilterUnit"]>;
+        path: MakeFilter<Path["FilterUnit"]>;
+    };
+    Filter: MakeFilter<ActionAuth["FilterUnit"]>;
+    SortAttr: Partial<BaseActionAuth.OpSortAttr | {
+        relation: Relation["SortAttr"];
+        path: Path["SortAttr"];
+    }>;
+    SortNode: {
+        $attr: ActionAuth["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: ActionAuth["SortNode"][];
+    Selection: OakSelection<"select", ActionAuth["Projection"], ActionAuth["Filter"], ActionAuth["Sorter"]>;
+    Aggregation: DeduceAggregation<ActionAuth["Projection"], ActionAuth["Filter"], ActionAuth["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseActionAuth.OpSchema & {
+        relation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]>;
+    }>;
+    CreateSingle: OakOperation<"create", ActionAuth["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<ActionAuth["CreateOperationData"]>>;
+    Create: ActionAuth["CreateSingle"] | ActionAuth["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseActionAuth.OpSchema & {
+        relation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]> | OakOperation<"remove", Relation["RemoveOperationData"], Relation["Filter"]>;
+    }>;
+    Update: OakOperation<BaseActionAuth.OpUpdateAction, ActionAuth["UpdateOperationData"], ActionAuth["Filter"], ActionAuth["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", ActionAuth["RemoveOperationData"], ActionAuth["Filter"], ActionAuth["Sorter"]>;
+    Operation: ActionAuth["Create"] | ActionAuth["Update"] | ActionAuth["Remove"];
+};
+export type I18n = {
+    OpSchema: BaseI18n.OpSchema;
+    Action: BaseI18n.OpAction;
+    Schema: BaseI18n.OpSchema & {};
+    Projection: BaseI18n.OpProjection & {};
+    FilterUnit: BaseI18n.OpFilter & {};
+    Filter: MakeFilter<I18n["FilterUnit"]>;
+    SortAttr: Partial<BaseI18n.OpSortAttr | {}>;
+    SortNode: {
+        $attr: I18n["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: I18n["SortNode"][];
+    Selection: OakSelection<"select", I18n["Projection"], I18n["Filter"], I18n["Sorter"]>;
+    Aggregation: DeduceAggregation<I18n["Projection"], I18n["Filter"], I18n["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseI18n.OpSchema>;
+    CreateSingle: OakOperation<"create", I18n["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<I18n["CreateOperationData"]>>;
+    Create: I18n["CreateSingle"] | I18n["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseI18n.OpSchema>;
+    Update: OakOperation<BaseI18n.OpUpdateAction, I18n["UpdateOperationData"], I18n["Filter"], I18n["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", I18n["RemoveOperationData"], I18n["Filter"], I18n["Sorter"]>;
+    Operation: I18n["Create"] | I18n["Update"] | I18n["Remove"];
+};
+export type Log = {
+    OpSchema: BaseLog.OpSchema;
+    Action: BaseLog.OpAction;
+    Schema: BaseLog.OpSchema & {
+        oper$log?: Array<Omit<Oper["Schema"], "log">>;
+        oper$log$$aggr?: AggregationResult<Omit<Oper["Schema"], "log">>;
+    };
+    Projection: BaseLog.OpProjection & {
+        oper$log?: OakSelection<"select", Omit<Oper["Projection"], "log">, Omit<Oper["Filter"], "log">, Oper["Sorter"]> & {
+            $entity: "oper";
+        };
+        oper$log$$aggr?: DeduceAggregation<Omit<Oper["Projection"], "log">, Omit<Oper["Filter"], "log">, Oper["Sorter"]> & {
+            $entity: "oper";
+        };
+    };
+    FilterUnit: BaseLog.OpFilter & {
+        oper$log: MakeFilter<Omit<Oper["FilterUnit"], "log">> & SubQueryPredicateMetadata;
+    };
+    Filter: MakeFilter<Log["FilterUnit"]>;
+    SortAttr: Partial<BaseLog.OpSortAttr | {}>;
+    SortNode: {
+        $attr: Log["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: Log["SortNode"][];
+    Selection: OakSelection<"select", Log["Projection"], Log["Filter"], Log["Sorter"]>;
+    Aggregation: DeduceAggregation<Log["Projection"], Log["Filter"], Log["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseLog.OpSchema & {
+        oper$log?: (OakOperation<"create", Omit<Oper["CreateOperationData"], "log"> | Omit<Oper["CreateOperationData"], "log">[]> | OakOperation<BaseOper.OpUpdateAction, Omit<Oper["UpdateOperationData"], "log">, Oper["Filter"]>)[];
+    }>;
+    CreateSingle: OakOperation<"create", Log["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<Log["CreateOperationData"]>>;
+    Create: Log["CreateSingle"] | Log["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseLog.OpSchema & {
+        oper$log?: (OakOperation<"create", Omit<Oper["CreateOperationData"], "log"> | Omit<Oper["CreateOperationData"], "log">[]> | OakOperation<BaseOper.OpUpdateAction, Omit<Oper["UpdateOperationData"], "log">, Oper["Filter"]> | OakOperation<"remove", Oper["RemoveOperationData"], Oper["Filter"]>)[];
+    }>;
+    Update: OakOperation<BaseLog.OpUpdateAction, Log["UpdateOperationData"], Log["Filter"], Log["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", Log["RemoveOperationData"], Log["Filter"], Log["Sorter"]>;
+    Operation: Log["Create"] | Log["Update"] | Log["Remove"];
+};
+export type Modi = {
+    OpSchema: BaseModi.OpSchema;
+    Action: BaseModi.OpAction;
+    Schema: BaseModi.OpSchema & {
+        modiEntity$modi?: Array<Omit<ModiEntity["Schema"], "modi">>;
+        modiEntity$modi$$aggr?: AggregationResult<Omit<ModiEntity["Schema"], "modi">>;
+    };
+    Projection: BaseModi.OpProjection & {
+        modiEntity$modi?: OakSelection<"select", Omit<ModiEntity["Projection"], "modi">, Omit<ModiEntity["Filter"], "modi">, ModiEntity["Sorter"]> & {
+            $entity: "modiEntity";
+        };
+        modiEntity$modi$$aggr?: DeduceAggregation<Omit<ModiEntity["Projection"], "modi">, Omit<ModiEntity["Filter"], "modi">, ModiEntity["Sorter"]> & {
+            $entity: "modiEntity";
+        };
+    };
+    FilterUnit: BaseModi.OpFilter & {
+        modiEntity$modi: MakeFilter<Omit<ModiEntity["FilterUnit"], "modi">> & SubQueryPredicateMetadata;
+    };
+    Filter: MakeFilter<Modi["FilterUnit"]>;
+    SortAttr: Partial<BaseModi.OpSortAttr | {}>;
+    SortNode: {
+        $attr: Modi["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: Modi["SortNode"][];
+    Selection: OakSelection<"select", Modi["Projection"], Modi["Filter"], Modi["Sorter"]>;
+    Aggregation: DeduceAggregation<Modi["Projection"], Modi["Filter"], Modi["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseModi.OpSchema & {
+        modiEntity$modi?: OakOperation<"create", Omit<ModiEntity["CreateOperationData"], "modi"> | Omit<ModiEntity["CreateOperationData"], "modi">[]>[];
+    }>;
+    CreateSingle: OakOperation<"create", Modi["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<Modi["CreateOperationData"]>>;
+    Create: Modi["CreateSingle"] | Modi["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseModi.OpSchema & {
+        modiEntity$modi?: OakOperation<"create", Omit<ModiEntity["CreateOperationData"], "modi"> | Omit<ModiEntity["CreateOperationData"], "modi">[]>[];
+    }>;
+    Update: OakOperation<BaseModi.OpUpdateAction, Modi["UpdateOperationData"], Modi["Filter"], Modi["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", Modi["RemoveOperationData"], Modi["Filter"], Modi["Sorter"]>;
+    Operation: Modi["Create"] | Modi["Update"] | Modi["Remove"];
+};
+export type ModiEntity = {
+    OpSchema: BaseModiEntity.OpSchema;
+    Action: BaseModiEntity.OpAction;
+    Schema: BaseModiEntity.OpSchema & {
+        modi: Modi["Schema"];
+    };
+    Projection: BaseModiEntity.OpProjection & {
+        modi?: Modi["Projection"];
+    };
+    FilterUnit: BaseModiEntity.OpFilter & {
+        modi: MakeFilter<Modi["FilterUnit"]>;
+    };
+    Filter: MakeFilter<ModiEntity["FilterUnit"]>;
+    SortAttr: Partial<BaseModiEntity.OpSortAttr | {
+        modi: Modi["SortAttr"];
+    }>;
+    SortNode: {
+        $attr: ModiEntity["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: ModiEntity["SortNode"][];
+    Selection: OakSelection<"select", ModiEntity["Projection"], ModiEntity["Filter"], ModiEntity["Sorter"]>;
+    Aggregation: DeduceAggregation<ModiEntity["Projection"], ModiEntity["Filter"], ModiEntity["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseModiEntity.OpSchema & {
+        modi?: OakOperation<"create", Modi["CreateOperationData"]> | OakOperation<BaseModi.OpUpdateAction, Modi["UpdateOperationData"], Modi["Filter"]>;
+    }>;
+    CreateSingle: OakOperation<"create", ModiEntity["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<ModiEntity["CreateOperationData"]>>;
+    Create: ModiEntity["CreateSingle"] | ModiEntity["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseModiEntity.OpSchema & {
+        modi?: OakOperation<"create", Modi["CreateOperationData"]> | OakOperation<BaseModi.OpUpdateAction, Modi["UpdateOperationData"], Modi["Filter"]> | OakOperation<"remove", Modi["RemoveOperationData"], Modi["Filter"]>;
+    }>;
+    Update: OakOperation<BaseModiEntity.OpUpdateAction, ModiEntity["UpdateOperationData"], ModiEntity["Filter"], ModiEntity["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", ModiEntity["RemoveOperationData"], ModiEntity["Filter"], ModiEntity["Sorter"]>;
+    Operation: ModiEntity["Create"] | ModiEntity["Update"] | ModiEntity["Remove"];
+};
+export type Oper = {
+    OpSchema: BaseOper.OpSchema;
+    Action: BaseOper.OpAction;
+    Schema: BaseOper.OpSchema & {
+        operator?: User["Schema"];
+        log?: Log["Schema"];
+        operEntity$oper?: Array<Omit<OperEntity["Schema"], "oper">>;
+        operEntity$oper$$aggr?: AggregationResult<Omit<OperEntity["Schema"], "oper">>;
+    };
+    Projection: BaseOper.OpProjection & {
+        operator?: User["Projection"];
+        log?: Log["Projection"];
+        operEntity$oper?: OakSelection<"select", Omit<OperEntity["Projection"], "oper">, Omit<OperEntity["Filter"], "oper">, OperEntity["Sorter"]> & {
+            $entity: "operEntity";
+        };
+        operEntity$oper$$aggr?: DeduceAggregation<Omit<OperEntity["Projection"], "oper">, Omit<OperEntity["Filter"], "oper">, OperEntity["Sorter"]> & {
+            $entity: "operEntity";
+        };
+    };
+    FilterUnit: BaseOper.OpFilter & {
+        operator: MakeFilter<User["FilterUnit"]>;
+        log: MakeFilter<Log["FilterUnit"]>;
+        operEntity$oper: MakeFilter<Omit<OperEntity["FilterUnit"], "oper">> & SubQueryPredicateMetadata;
+    };
+    Filter: MakeFilter<Oper["FilterUnit"]>;
+    SortAttr: Partial<BaseOper.OpSortAttr | {
+        operator: User["SortAttr"];
+        log: Log["SortAttr"];
+    }>;
+    SortNode: {
+        $attr: Oper["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: Oper["SortNode"][];
+    Selection: OakSelection<"select", Oper["Projection"], Oper["Filter"], Oper["Sorter"]>;
+    Aggregation: DeduceAggregation<Oper["Projection"], Oper["Filter"], Oper["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseOper.OpSchema & {
+        operator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
+        log?: OakOperation<"create", Log["CreateOperationData"]> | OakOperation<BaseLog.OpUpdateAction, Log["UpdateOperationData"], Log["Filter"]>;
+        operEntity$oper?: OakOperation<"create", Omit<OperEntity["CreateOperationData"], "oper"> | Omit<OperEntity["CreateOperationData"], "oper">[]>[];
+    }>;
+    CreateSingle: OakOperation<"create", Oper["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<Oper["CreateOperationData"]>>;
+    Create: Oper["CreateSingle"] | Oper["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseOper.OpSchema & {
+        operator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
+        log?: OakOperation<"create", Log["CreateOperationData"]> | OakOperation<BaseLog.OpUpdateAction, Log["UpdateOperationData"], Log["Filter"]> | OakOperation<"remove", Log["RemoveOperationData"], Log["Filter"]>;
+        operEntity$oper?: OakOperation<"create", Omit<OperEntity["CreateOperationData"], "oper"> | Omit<OperEntity["CreateOperationData"], "oper">[]>[];
+    }>;
+    Update: OakOperation<BaseOper.OpUpdateAction, Oper["UpdateOperationData"], Oper["Filter"], Oper["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", Oper["RemoveOperationData"], Oper["Filter"], Oper["Sorter"]>;
+    Operation: Oper["Create"] | Oper["Update"] | Oper["Remove"];
+};
+export type OperEntity = {
+    OpSchema: BaseOperEntity.OpSchema;
+    Action: BaseOperEntity.OpAction;
+    Schema: BaseOperEntity.OpSchema & {
+        oper: Oper["Schema"];
+    };
+    Projection: BaseOperEntity.OpProjection & {
+        oper?: Oper["Projection"];
+    };
+    FilterUnit: BaseOperEntity.OpFilter & {
+        oper: MakeFilter<Oper["FilterUnit"]>;
+    };
+    Filter: MakeFilter<OperEntity["FilterUnit"]>;
+    SortAttr: Partial<BaseOperEntity.OpSortAttr | {
+        oper: Oper["SortAttr"];
+    }>;
+    SortNode: {
+        $attr: OperEntity["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: OperEntity["SortNode"][];
+    Selection: OakSelection<"select", OperEntity["Projection"], OperEntity["Filter"], OperEntity["Sorter"]>;
+    Aggregation: DeduceAggregation<OperEntity["Projection"], OperEntity["Filter"], OperEntity["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseOperEntity.OpSchema & {
+        oper?: OakOperation<"create", Oper["CreateOperationData"]> | OakOperation<BaseOper.OpUpdateAction, Oper["UpdateOperationData"], Oper["Filter"]>;
+    }>;
+    CreateSingle: OakOperation<"create", OperEntity["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<OperEntity["CreateOperationData"]>>;
+    Create: OperEntity["CreateSingle"] | OperEntity["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseOperEntity.OpSchema & {
+        oper?: OakOperation<"create", Oper["CreateOperationData"]> | OakOperation<BaseOper.OpUpdateAction, Oper["UpdateOperationData"], Oper["Filter"]> | OakOperation<"remove", Oper["RemoveOperationData"], Oper["Filter"]>;
+    }>;
+    Update: OakOperation<BaseOperEntity.OpUpdateAction, OperEntity["UpdateOperationData"], OperEntity["Filter"], OperEntity["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", OperEntity["RemoveOperationData"], OperEntity["Filter"], OperEntity["Sorter"]>;
+    Operation: OperEntity["Create"] | OperEntity["Update"] | OperEntity["Remove"];
+};
+export type Path = {
+    OpSchema: BasePath.OpSchema;
+    Action: BasePath.OpAction;
+    Schema: BasePath.OpSchema & {
+        actionAuth$path?: Array<Omit<ActionAuth["Schema"], "path">>;
+        relationAuth$path?: Array<Omit<RelationAuth["Schema"], "path">>;
+        actionAuth$path$$aggr?: AggregationResult<Omit<ActionAuth["Schema"], "path">>;
+        relationAuth$path$$aggr?: AggregationResult<Omit<RelationAuth["Schema"], "path">>;
+    };
+    Projection: BasePath.OpProjection & {
+        actionAuth$path?: OakSelection<"select", Omit<ActionAuth["Projection"], "path">, Omit<ActionAuth["Filter"], "path">, ActionAuth["Sorter"]> & {
+            $entity: "actionAuth";
+        };
+        actionAuth$path$$aggr?: DeduceAggregation<Omit<ActionAuth["Projection"], "path">, Omit<ActionAuth["Filter"], "path">, ActionAuth["Sorter"]> & {
+            $entity: "actionAuth";
+        };
+        relationAuth$path?: OakSelection<"select", Omit<RelationAuth["Projection"], "path">, Omit<RelationAuth["Filter"], "path">, RelationAuth["Sorter"]> & {
+            $entity: "relationAuth";
+        };
+        relationAuth$path$$aggr?: DeduceAggregation<Omit<RelationAuth["Projection"], "path">, Omit<RelationAuth["Filter"], "path">, RelationAuth["Sorter"]> & {
+            $entity: "relationAuth";
+        };
+    };
+    FilterUnit: BasePath.OpFilter & {
+        actionAuth$path: MakeFilter<Omit<ActionAuth["FilterUnit"], "path">> & SubQueryPredicateMetadata;
+        relationAuth$path: MakeFilter<Omit<RelationAuth["FilterUnit"], "path">> & SubQueryPredicateMetadata;
+    };
+    Filter: MakeFilter<Path["FilterUnit"]>;
+    SortAttr: Partial<BasePath.OpSortAttr | {}>;
+    SortNode: {
+        $attr: Path["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: Path["SortNode"][];
+    Selection: OakSelection<"select", Path["Projection"], Path["Filter"], Path["Sorter"]>;
+    Aggregation: DeduceAggregation<Path["Projection"], Path["Filter"], Path["Sorter"]>;
+    CreateOperationData: FormCreateData<BasePath.OpSchema>;
+    CreateSingle: OakOperation<"create", Path["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<Path["CreateOperationData"]>>;
+    Create: Path["CreateSingle"] | Path["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BasePath.OpSchema>;
+    Update: OakOperation<BasePath.OpUpdateAction, Path["UpdateOperationData"], Path["Filter"], Path["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", Path["RemoveOperationData"], Path["Filter"], Path["Sorter"]>;
+    Operation: Path["Create"] | Path["Update"] | Path["Remove"];
+};
+export type Relation = {
+    OpSchema: BaseRelation.OpSchema;
+    Action: BaseRelation.OpAction;
+    Schema: BaseRelation.OpSchema & {
+        actionAuth$relation?: Array<Omit<ActionAuth["Schema"], "relation">>;
+        relationAuth$sourceRelation?: Array<Omit<RelationAuth["Schema"], "sourceRelation">>;
+        relationAuth$destRelation?: Array<Omit<RelationAuth["Schema"], "destRelation">>;
+        userEntityClaim$relation?: Array<Omit<UserEntityClaim["Schema"], "relation">>;
+        userRelation$relation?: Array<Omit<UserRelation["Schema"], "relation">>;
+        actionAuth$relation$$aggr?: AggregationResult<Omit<ActionAuth["Schema"], "relation">>;
+        relationAuth$sourceRelation$$aggr?: AggregationResult<Omit<RelationAuth["Schema"], "sourceRelation">>;
+        relationAuth$destRelation$$aggr?: AggregationResult<Omit<RelationAuth["Schema"], "destRelation">>;
+        userEntityClaim$relation$$aggr?: AggregationResult<Omit<UserEntityClaim["Schema"], "relation">>;
+        userRelation$relation$$aggr?: AggregationResult<Omit<UserRelation["Schema"], "relation">>;
+    };
+    Projection: BaseRelation.OpProjection & {
+        actionAuth$relation?: OakSelection<"select", Omit<ActionAuth["Projection"], "relation">, Omit<ActionAuth["Filter"], "relation">, ActionAuth["Sorter"]> & {
+            $entity: "actionAuth";
+        };
+        actionAuth$relation$$aggr?: DeduceAggregation<Omit<ActionAuth["Projection"], "relation">, Omit<ActionAuth["Filter"], "relation">, ActionAuth["Sorter"]> & {
+            $entity: "actionAuth";
+        };
+        relationAuth$sourceRelation?: OakSelection<"select", Omit<RelationAuth["Projection"], "relation">, Omit<RelationAuth["Filter"], "relation">, RelationAuth["Sorter"]> & {
+            $entity: "relationAuth";
+        };
+        relationAuth$sourceRelation$$aggr?: DeduceAggregation<Omit<RelationAuth["Projection"], "relation">, Omit<RelationAuth["Filter"], "relation">, RelationAuth["Sorter"]> & {
+            $entity: "relationAuth";
+        };
+        relationAuth$destRelation?: OakSelection<"select", Omit<RelationAuth["Projection"], "relation">, Omit<RelationAuth["Filter"], "relation">, RelationAuth["Sorter"]> & {
+            $entity: "relationAuth";
+        };
+        relationAuth$destRelation$$aggr?: DeduceAggregation<Omit<RelationAuth["Projection"], "relation">, Omit<RelationAuth["Filter"], "relation">, RelationAuth["Sorter"]> & {
+            $entity: "relationAuth";
+        };
+        userEntityClaim$relation?: OakSelection<"select", Omit<UserEntityClaim["Projection"], "relation">, Omit<UserEntityClaim["Filter"], "relation">, UserEntityClaim["Sorter"]> & {
+            $entity: "userEntityClaim";
+        };
+        userEntityClaim$relation$$aggr?: DeduceAggregation<Omit<UserEntityClaim["Projection"], "relation">, Omit<UserEntityClaim["Filter"], "relation">, UserEntityClaim["Sorter"]> & {
+            $entity: "userEntityClaim";
+        };
+        userRelation$relation?: OakSelection<"select", Omit<UserRelation["Projection"], "relation">, Omit<UserRelation["Filter"], "relation">, UserRelation["Sorter"]> & {
+            $entity: "userRelation";
+        };
+        userRelation$relation$$aggr?: DeduceAggregation<Omit<UserRelation["Projection"], "relation">, Omit<UserRelation["Filter"], "relation">, UserRelation["Sorter"]> & {
+            $entity: "userRelation";
+        };
+    };
+    FilterUnit: BaseRelation.OpFilter & {
+        actionAuth$relation: MakeFilter<Omit<ActionAuth["FilterUnit"], "relation">> & SubQueryPredicateMetadata;
+        relationAuth$sourceRelation: MakeFilter<Omit<RelationAuth["FilterUnit"], "sourceRelation">> & SubQueryPredicateMetadata;
+        relationAuth$destRelation: MakeFilter<Omit<RelationAuth["FilterUnit"], "destRelation">> & SubQueryPredicateMetadata;
+        userEntityClaim$relation: MakeFilter<Omit<UserEntityClaim["FilterUnit"], "relation">> & SubQueryPredicateMetadata;
+        userRelation$relation: MakeFilter<Omit<UserRelation["FilterUnit"], "relation">> & SubQueryPredicateMetadata;
+    };
+    Filter: MakeFilter<Relation["FilterUnit"]>;
+    SortAttr: Partial<BaseRelation.OpSortAttr | {}>;
+    SortNode: {
+        $attr: Relation["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: Relation["SortNode"][];
+    Selection: OakSelection<"select", Relation["Projection"], Relation["Filter"], Relation["Sorter"]>;
+    Aggregation: DeduceAggregation<Relation["Projection"], Relation["Filter"], Relation["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseRelation.OpSchema & {
+        userEntityClaim$relation?: (OakOperation<"create", Omit<UserEntityClaim["CreateOperationData"], "relation"> | Omit<UserEntityClaim["CreateOperationData"], "relation">[]> | OakOperation<BaseUserEntityClaim.OpUpdateAction, Omit<UserEntityClaim["UpdateOperationData"], "relation">, UserEntityClaim["Filter"]>)[];
+        userRelation$relation?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "relation"> | Omit<UserRelation["CreateOperationData"], "relation">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "relation">, UserRelation["Filter"]>)[];
+    }>;
+    CreateSingle: OakOperation<"create", Relation["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<Relation["CreateOperationData"]>>;
+    Create: Relation["CreateSingle"] | Relation["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseRelation.OpSchema & {
+        userEntityClaim$relation?: (OakOperation<"create", Omit<UserEntityClaim["CreateOperationData"], "relation"> | Omit<UserEntityClaim["CreateOperationData"], "relation">[]> | OakOperation<BaseUserEntityClaim.OpUpdateAction, Omit<UserEntityClaim["UpdateOperationData"], "relation">, UserEntityClaim["Filter"]> | OakOperation<"remove", UserEntityClaim["RemoveOperationData"], UserEntityClaim["Filter"]>)[];
+        userRelation$relation?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "relation"> | Omit<UserRelation["CreateOperationData"], "relation">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "relation">, UserRelation["Filter"]> | OakOperation<"remove", UserRelation["RemoveOperationData"], UserRelation["Filter"]>)[];
+    }>;
+    Update: OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"], Relation["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", Relation["RemoveOperationData"], Relation["Filter"], Relation["Sorter"]>;
+    Operation: Relation["Create"] | Relation["Update"] | Relation["Remove"];
+};
+export type RelationAuth = {
+    OpSchema: BaseRelationAuth.OpSchema;
+    Action: BaseRelationAuth.OpAction;
+    Schema: BaseRelationAuth.OpSchema & {
+        sourceRelation: Relation["Schema"];
+        path: Path["Schema"];
+        destRelation: Relation["Schema"];
+    };
+    Projection: BaseRelationAuth.OpProjection & {
+        sourceRelation?: Relation["Projection"];
+        path?: Path["Projection"];
+        destRelation?: Relation["Projection"];
+    };
+    FilterUnit: BaseRelationAuth.OpFilter & {
+        sourceRelation: MakeFilter<Relation["FilterUnit"]>;
+        path: MakeFilter<Path["FilterUnit"]>;
+        destRelation: MakeFilter<Relation["FilterUnit"]>;
+    };
+    Filter: MakeFilter<RelationAuth["FilterUnit"]>;
+    SortAttr: Partial<BaseRelationAuth.OpSortAttr | {
+        sourceRelation: Relation["SortAttr"];
+        path: Path["SortAttr"];
+        destRelation: Relation["SortAttr"];
+    }>;
+    SortNode: {
+        $attr: RelationAuth["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: RelationAuth["SortNode"][];
+    Selection: OakSelection<"select", RelationAuth["Projection"], RelationAuth["Filter"], RelationAuth["Sorter"]>;
+    Aggregation: DeduceAggregation<RelationAuth["Projection"], RelationAuth["Filter"], RelationAuth["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseRelationAuth.OpSchema & {
+        sourceRelation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]>;
+        destRelation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]>;
+    }>;
+    CreateSingle: OakOperation<"create", RelationAuth["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<RelationAuth["CreateOperationData"]>>;
+    Create: RelationAuth["CreateSingle"] | RelationAuth["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseRelationAuth.OpSchema & {
+        sourceRelation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]> | OakOperation<"remove", Relation["RemoveOperationData"], Relation["Filter"]>;
+        destRelation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]> | OakOperation<"remove", Relation["RemoveOperationData"], Relation["Filter"]>;
+    }>;
+    Update: OakOperation<BaseRelationAuth.OpUpdateAction, RelationAuth["UpdateOperationData"], RelationAuth["Filter"], RelationAuth["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", RelationAuth["RemoveOperationData"], RelationAuth["Filter"], RelationAuth["Sorter"]>;
+    Operation: RelationAuth["Create"] | RelationAuth["Update"] | RelationAuth["Remove"];
+};
+export type User = {
+    OpSchema: BaseUser.OpSchema;
+    Action: BaseUser.OpAction;
+    Schema: BaseUser.OpSchema & {
+        ref?: User["Schema"];
+        oper$operator?: Array<Omit<Oper["Schema"], "operator">>;
+        user$ref?: Array<Omit<User["Schema"], "ref">>;
+        userEntityClaim$user?: Array<Omit<UserEntityClaim["Schema"], "user">>;
+        userRelation$user?: Array<Omit<UserRelation["Schema"], "user">>;
+        oper$operator$$aggr?: AggregationResult<Omit<Oper["Schema"], "operator">>;
+        user$ref$$aggr?: AggregationResult<Omit<User["Schema"], "ref">>;
+        userEntityClaim$user$$aggr?: AggregationResult<Omit<UserEntityClaim["Schema"], "user">>;
+        userRelation$user$$aggr?: AggregationResult<Omit<UserRelation["Schema"], "user">>;
+    };
+    Projection: BaseUser.OpProjection & {
+        ref?: User["Projection"];
+        oper$operator?: OakSelection<"select", Omit<Oper["Projection"], "user">, Omit<Oper["Filter"], "user">, Oper["Sorter"]> & {
+            $entity: "oper";
+        };
+        oper$operator$$aggr?: DeduceAggregation<Omit<Oper["Projection"], "user">, Omit<Oper["Filter"], "user">, Oper["Sorter"]> & {
+            $entity: "oper";
+        };
+        user$ref?: OakSelection<"select", Omit<User["Projection"], "user">, Omit<User["Filter"], "user">, User["Sorter"]> & {
+            $entity: "user";
+        };
+        user$ref$$aggr?: DeduceAggregation<Omit<User["Projection"], "user">, Omit<User["Filter"], "user">, User["Sorter"]> & {
+            $entity: "user";
+        };
+        userEntityClaim$user?: OakSelection<"select", Omit<UserEntityClaim["Projection"], "user">, Omit<UserEntityClaim["Filter"], "user">, UserEntityClaim["Sorter"]> & {
+            $entity: "userEntityClaim";
+        };
+        userEntityClaim$user$$aggr?: DeduceAggregation<Omit<UserEntityClaim["Projection"], "user">, Omit<UserEntityClaim["Filter"], "user">, UserEntityClaim["Sorter"]> & {
+            $entity: "userEntityClaim";
+        };
+        userRelation$user?: OakSelection<"select", Omit<UserRelation["Projection"], "user">, Omit<UserRelation["Filter"], "user">, UserRelation["Sorter"]> & {
+            $entity: "userRelation";
+        };
+        userRelation$user$$aggr?: DeduceAggregation<Omit<UserRelation["Projection"], "user">, Omit<UserRelation["Filter"], "user">, UserRelation["Sorter"]> & {
+            $entity: "userRelation";
+        };
+    };
+    FilterUnit: BaseUser.OpFilter & {
+        ref: MakeFilter<User["FilterUnit"]>;
+        oper$operator: MakeFilter<Omit<Oper["FilterUnit"], "operator">> & SubQueryPredicateMetadata;
+        user$ref: MakeFilter<Omit<User["FilterUnit"], "ref">> & SubQueryPredicateMetadata;
+        userEntityClaim$user: MakeFilter<Omit<UserEntityClaim["FilterUnit"], "user">> & SubQueryPredicateMetadata;
+        userRelation$user: MakeFilter<Omit<UserRelation["FilterUnit"], "user">> & SubQueryPredicateMetadata;
+    };
+    Filter: MakeFilter<User["FilterUnit"]>;
+    SortAttr: Partial<BaseUser.OpSortAttr | {
+        ref: User["SortAttr"];
+    }>;
+    SortNode: {
+        $attr: User["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: User["SortNode"][];
+    Selection: OakSelection<"select", User["Projection"], User["Filter"], User["Sorter"]>;
+    Aggregation: DeduceAggregation<User["Projection"], User["Filter"], User["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseUser.OpSchema & {
+        ref?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
+        oper$operator?: (OakOperation<"create", Omit<Oper["CreateOperationData"], "operator"> | Omit<Oper["CreateOperationData"], "operator">[]> | OakOperation<BaseOper.OpUpdateAction, Omit<Oper["UpdateOperationData"], "operator">, Oper["Filter"]>)[];
+        user$ref?: (OakOperation<"create", Omit<User["CreateOperationData"], "ref"> | Omit<User["CreateOperationData"], "ref">[]> | OakOperation<BaseUser.OpUpdateAction, Omit<User["UpdateOperationData"], "ref">, User["Filter"]>)[];
+        userEntityClaim$user?: (OakOperation<"create", Omit<UserEntityClaim["CreateOperationData"], "user"> | Omit<UserEntityClaim["CreateOperationData"], "user">[]> | OakOperation<BaseUserEntityClaim.OpUpdateAction, Omit<UserEntityClaim["UpdateOperationData"], "user">, UserEntityClaim["Filter"]>)[];
+        userRelation$user?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "user"> | Omit<UserRelation["CreateOperationData"], "user">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "user">, UserRelation["Filter"]>)[];
+    }>;
+    CreateSingle: OakOperation<"create", User["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<User["CreateOperationData"]>>;
+    Create: User["CreateSingle"] | User["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseUser.OpSchema & {
+        ref?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
+        oper$operator?: (OakOperation<"create", Omit<Oper["CreateOperationData"], "operator"> | Omit<Oper["CreateOperationData"], "operator">[]> | OakOperation<BaseOper.OpUpdateAction, Omit<Oper["UpdateOperationData"], "operator">, Oper["Filter"]> | OakOperation<"remove", Oper["RemoveOperationData"], Oper["Filter"]>)[];
+        user$ref?: (OakOperation<"create", Omit<User["CreateOperationData"], "ref"> | Omit<User["CreateOperationData"], "ref">[]> | OakOperation<BaseUser.OpUpdateAction, Omit<User["UpdateOperationData"], "ref">, User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>)[];
+        userEntityClaim$user?: (OakOperation<"create", Omit<UserEntityClaim["CreateOperationData"], "user"> | Omit<UserEntityClaim["CreateOperationData"], "user">[]> | OakOperation<BaseUserEntityClaim.OpUpdateAction, Omit<UserEntityClaim["UpdateOperationData"], "user">, UserEntityClaim["Filter"]> | OakOperation<"remove", UserEntityClaim["RemoveOperationData"], UserEntityClaim["Filter"]>)[];
+        userRelation$user?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "user"> | Omit<UserRelation["CreateOperationData"], "user">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "user">, UserRelation["Filter"]> | OakOperation<"remove", UserRelation["RemoveOperationData"], UserRelation["Filter"]>)[];
+    }>;
+    Update: OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"], User["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", User["RemoveOperationData"], User["Filter"], User["Sorter"]>;
+    Operation: User["Create"] | User["Update"] | User["Remove"];
+};
+export type UserEntityClaim = {
+    OpSchema: BaseUserEntityClaim.OpSchema;
+    Action: BaseUserEntityClaim.OpAction;
+    Schema: BaseUserEntityClaim.OpSchema & {
+        ueg: UserEntityGrant["Schema"];
+        user: User["Schema"];
+        relation: Relation["Schema"];
+        userRelation: UserRelation["Schema"];
+    };
+    Projection: BaseUserEntityClaim.OpProjection & {
+        ueg?: UserEntityGrant["Projection"];
+        user?: User["Projection"];
+        relation?: Relation["Projection"];
+        userRelation?: UserRelation["Projection"];
+    };
+    FilterUnit: BaseUserEntityClaim.OpFilter & {
+        ueg: MakeFilter<UserEntityGrant["FilterUnit"]>;
+        user: MakeFilter<User["FilterUnit"]>;
+        relation: MakeFilter<Relation["FilterUnit"]>;
+        userRelation: MakeFilter<UserRelation["FilterUnit"]>;
+    };
+    Filter: MakeFilter<UserEntityClaim["FilterUnit"]>;
+    SortAttr: Partial<BaseUserEntityClaim.OpSortAttr | {
+        ueg: UserEntityGrant["SortAttr"];
+        user: User["SortAttr"];
+        relation: Relation["SortAttr"];
+        userRelation: UserRelation["SortAttr"];
+    }>;
+    SortNode: {
+        $attr: UserEntityClaim["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: UserEntityClaim["SortNode"][];
+    Selection: OakSelection<"select", UserEntityClaim["Projection"], UserEntityClaim["Filter"], UserEntityClaim["Sorter"]>;
+    Aggregation: DeduceAggregation<UserEntityClaim["Projection"], UserEntityClaim["Filter"], UserEntityClaim["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseUserEntityClaim.OpSchema & {
+        ueg?: OakOperation<"create", UserEntityGrant["CreateOperationData"]> | OakOperation<BaseUserEntityGrant.OpUpdateAction, UserEntityGrant["UpdateOperationData"], UserEntityGrant["Filter"]>;
+        user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
+        relation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]>;
+        userRelation?: OakOperation<"create", UserRelation["CreateOperationData"]> | OakOperation<BaseUserRelation.OpUpdateAction, UserRelation["UpdateOperationData"], UserRelation["Filter"]>;
+    }>;
+    CreateSingle: OakOperation<"create", UserEntityClaim["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<UserEntityClaim["CreateOperationData"]>>;
+    Create: UserEntityClaim["CreateSingle"] | UserEntityClaim["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseUserEntityClaim.OpSchema & {
+        ueg?: OakOperation<"create", UserEntityGrant["CreateOperationData"]> | OakOperation<BaseUserEntityGrant.OpUpdateAction, UserEntityGrant["UpdateOperationData"], UserEntityGrant["Filter"]> | OakOperation<"remove", UserEntityGrant["RemoveOperationData"], UserEntityGrant["Filter"]>;
+        user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
+        relation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]> | OakOperation<"remove", Relation["RemoveOperationData"], Relation["Filter"]>;
+        userRelation?: OakOperation<"create", UserRelation["CreateOperationData"]> | OakOperation<BaseUserRelation.OpUpdateAction, UserRelation["UpdateOperationData"], UserRelation["Filter"]> | OakOperation<"remove", UserRelation["RemoveOperationData"], UserRelation["Filter"]>;
+    }>;
+    Update: OakOperation<BaseUserEntityClaim.OpUpdateAction, UserEntityClaim["UpdateOperationData"], UserEntityClaim["Filter"], UserEntityClaim["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", UserEntityClaim["RemoveOperationData"], UserEntityClaim["Filter"], UserEntityClaim["Sorter"]>;
+    Operation: UserEntityClaim["Create"] | UserEntityClaim["Update"] | UserEntityClaim["Remove"];
+};
+export type UserEntityGrant = {
+    OpSchema: BaseUserEntityGrant.OpSchema;
+    Action: BaseUserEntityGrant.OpAction;
+    Schema: BaseUserEntityGrant.OpSchema & {
+        userEntityClaim$ueg?: Array<Omit<UserEntityClaim["Schema"], "ueg">>;
+        userEntityClaim$ueg$$aggr?: AggregationResult<Omit<UserEntityClaim["Schema"], "ueg">>;
+    };
+    Projection: BaseUserEntityGrant.OpProjection & {
+        userEntityClaim$ueg?: OakSelection<"select", Omit<UserEntityClaim["Projection"], "userEntityGrant">, Omit<UserEntityClaim["Filter"], "userEntityGrant">, UserEntityClaim["Sorter"]> & {
+            $entity: "userEntityClaim";
+        };
+        userEntityClaim$ueg$$aggr?: DeduceAggregation<Omit<UserEntityClaim["Projection"], "userEntityGrant">, Omit<UserEntityClaim["Filter"], "userEntityGrant">, UserEntityClaim["Sorter"]> & {
+            $entity: "userEntityClaim";
+        };
+    };
+    FilterUnit: BaseUserEntityGrant.OpFilter & {
+        userEntityClaim$ueg: MakeFilter<Omit<UserEntityClaim["FilterUnit"], "ueg">> & SubQueryPredicateMetadata;
+    };
+    Filter: MakeFilter<UserEntityGrant["FilterUnit"]>;
+    SortAttr: Partial<BaseUserEntityGrant.OpSortAttr | {}>;
+    SortNode: {
+        $attr: UserEntityGrant["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: UserEntityGrant["SortNode"][];
+    Selection: OakSelection<"select", UserEntityGrant["Projection"], UserEntityGrant["Filter"], UserEntityGrant["Sorter"]>;
+    Aggregation: DeduceAggregation<UserEntityGrant["Projection"], UserEntityGrant["Filter"], UserEntityGrant["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseUserEntityGrant.OpSchema & {
+        userEntityClaim$ueg?: (OakOperation<"create", Omit<UserEntityClaim["CreateOperationData"], "ueg"> | Omit<UserEntityClaim["CreateOperationData"], "ueg">[]> | OakOperation<BaseUserEntityClaim.OpUpdateAction, Omit<UserEntityClaim["UpdateOperationData"], "ueg">, UserEntityClaim["Filter"]>)[];
+    }>;
+    CreateSingle: OakOperation<"create", UserEntityGrant["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<UserEntityGrant["CreateOperationData"]>>;
+    Create: UserEntityGrant["CreateSingle"] | UserEntityGrant["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseUserEntityGrant.OpSchema & {
+        userEntityClaim$ueg?: (OakOperation<"create", Omit<UserEntityClaim["CreateOperationData"], "ueg"> | Omit<UserEntityClaim["CreateOperationData"], "ueg">[]> | OakOperation<BaseUserEntityClaim.OpUpdateAction, Omit<UserEntityClaim["UpdateOperationData"], "ueg">, UserEntityClaim["Filter"]> | OakOperation<"remove", UserEntityClaim["RemoveOperationData"], UserEntityClaim["Filter"]>)[];
+    }>;
+    Update: OakOperation<BaseUserEntityGrant.OpUpdateAction, UserEntityGrant["UpdateOperationData"], UserEntityGrant["Filter"], UserEntityGrant["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", UserEntityGrant["RemoveOperationData"], UserEntityGrant["Filter"], UserEntityGrant["Sorter"]>;
+    Operation: UserEntityGrant["Create"] | UserEntityGrant["Update"] | UserEntityGrant["Remove"];
+};
+export type UserRelation = {
+    OpSchema: BaseUserRelation.OpSchema;
+    Action: BaseUserRelation.OpAction;
+    Schema: BaseUserRelation.OpSchema & {
+        user: User["Schema"];
+        relation: Relation["Schema"];
+        userEntityClaim$userRelation?: Array<Omit<UserEntityClaim["Schema"], "userRelation">>;
+        userEntityClaim$userRelation$$aggr?: AggregationResult<Omit<UserEntityClaim["Schema"], "userRelation">>;
+    };
+    Projection: BaseUserRelation.OpProjection & {
+        user?: User["Projection"];
+        relation?: Relation["Projection"];
+        userEntityClaim$userRelation?: OakSelection<"select", Omit<UserEntityClaim["Projection"], "userRelation">, Omit<UserEntityClaim["Filter"], "userRelation">, UserEntityClaim["Sorter"]> & {
+            $entity: "userEntityClaim";
+        };
+        userEntityClaim$userRelation$$aggr?: DeduceAggregation<Omit<UserEntityClaim["Projection"], "userRelation">, Omit<UserEntityClaim["Filter"], "userRelation">, UserEntityClaim["Sorter"]> & {
+            $entity: "userEntityClaim";
+        };
+    };
+    FilterUnit: BaseUserRelation.OpFilter & {
+        user: MakeFilter<User["FilterUnit"]>;
+        relation: MakeFilter<Relation["FilterUnit"]>;
+        userEntityClaim$userRelation: MakeFilter<Omit<UserEntityClaim["FilterUnit"], "userRelation">> & SubQueryPredicateMetadata;
+    };
+    Filter: MakeFilter<UserRelation["FilterUnit"]>;
+    SortAttr: Partial<BaseUserRelation.OpSortAttr | {
+        user: User["SortAttr"];
+        relation: Relation["SortAttr"];
+    }>;
+    SortNode: {
+        $attr: UserRelation["SortAttr"];
+        $direction?: "asc" | "desc";
+    };
+    Sorter: UserRelation["SortNode"][];
+    Selection: OakSelection<"select", UserRelation["Projection"], UserRelation["Filter"], UserRelation["Sorter"]>;
+    Aggregation: DeduceAggregation<UserRelation["Projection"], UserRelation["Filter"], UserRelation["Sorter"]>;
+    CreateOperationData: FormCreateData<BaseUserRelation.OpSchema & {
+        user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
+        relation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]>;
+        userEntityClaim$userRelation?: (OakOperation<"create", Omit<UserEntityClaim["CreateOperationData"], "userRelation"> | Omit<UserEntityClaim["CreateOperationData"], "userRelation">[]> | OakOperation<BaseUserEntityClaim.OpUpdateAction, Omit<UserEntityClaim["UpdateOperationData"], "userRelation">, UserEntityClaim["Filter"]>)[];
+    }>;
+    CreateSingle: OakOperation<"create", UserRelation["CreateOperationData"]>;
+    CreateMulti: OakOperation<"create", Array<UserRelation["CreateOperationData"]>>;
+    Create: UserRelation["CreateSingle"] | UserRelation["CreateMulti"];
+    UpdateOperationData: FormUpdateData<BaseUserRelation.OpSchema & {
+        user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
+        relation?: OakOperation<"create", Relation["CreateOperationData"]> | OakOperation<BaseRelation.OpUpdateAction, Relation["UpdateOperationData"], Relation["Filter"]> | OakOperation<"remove", Relation["RemoveOperationData"], Relation["Filter"]>;
+        userEntityClaim$userRelation?: (OakOperation<"create", Omit<UserEntityClaim["CreateOperationData"], "userRelation"> | Omit<UserEntityClaim["CreateOperationData"], "userRelation">[]> | OakOperation<BaseUserEntityClaim.OpUpdateAction, Omit<UserEntityClaim["UpdateOperationData"], "userRelation">, UserEntityClaim["Filter"]> | OakOperation<"remove", UserEntityClaim["RemoveOperationData"], UserEntityClaim["Filter"]>)[];
+    }>;
+    Update: OakOperation<BaseUserRelation.OpUpdateAction, UserRelation["UpdateOperationData"], UserRelation["Filter"], UserRelation["Sorter"]>;
+    RemoveOperationData: {};
+    Remove: OakOperation<"remove", UserRelation["RemoveOperationData"], UserRelation["Filter"], UserRelation["Sorter"]>;
+    Operation: UserRelation["Create"] | UserRelation["Update"] | UserRelation["Remove"];
+};
 export type EntityDict = {
     actionAuth: ActionAuth;
     i18n: I18n;