6364 lines
506 KiB
TypeScript
6364 lines
506 KiB
TypeScript
import { MakeFilter, FulltextFilter, SubQueryPredicateMetadata } from "oak-domain/lib/types/Demand";
|
|
import { FormCreateData, FormUpdateData, DeduceAggregation, Operation as OakOperation, Selection as OakSelection, AggregationResult } from "oak-domain/lib/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";
|
|
import * as BaseAddress from "./Address/_baseSchema";
|
|
import * as BaseApplication from "./Application/_baseSchema";
|
|
import * as BaseApplicationPassport from "./ApplicationPassport/_baseSchema";
|
|
import * as BaseArea from "./Area/_baseSchema";
|
|
import * as BaseArticle from "./Article/_baseSchema";
|
|
import * as BaseArticleMenu from "./ArticleMenu/_baseSchema";
|
|
import * as BaseCaptcha from "./Captcha/_baseSchema";
|
|
import * as BaseChangePasswordTemp from "./ChangePasswordTemp/_baseSchema";
|
|
import * as BaseDomain from "./Domain/_baseSchema";
|
|
import * as BaseEmail from "./Email/_baseSchema";
|
|
import * as BaseExtraFile from "./ExtraFile/_baseSchema";
|
|
import * as BaseLivestream from "./Livestream/_baseSchema";
|
|
import * as BaseLoginName from "./LoginName/_baseSchema";
|
|
import * as BaseMessage from "./Message/_baseSchema";
|
|
import * as BaseMessageSystem from "./MessageSystem/_baseSchema";
|
|
import * as BaseMessageType from "./MessageType/_baseSchema";
|
|
import * as BaseMessageTypeSmsTemplate from "./MessageTypeSmsTemplate/_baseSchema";
|
|
import * as BaseMessageTypeTemplate from "./MessageTypeTemplate/_baseSchema";
|
|
import * as BaseMobile from "./Mobile/_baseSchema";
|
|
import * as BaseNotification from "./Notification/_baseSchema";
|
|
import * as BaseOauthApplication from "./OauthApplication/_baseSchema";
|
|
import * as BaseOauthAuthorizationCode from "./OauthAuthorizationCode/_baseSchema";
|
|
import * as BaseOauthProvider from "./OauthProvider/_baseSchema";
|
|
import * as BaseOauthState from "./OauthState/_baseSchema";
|
|
import * as BaseOauthToken from "./OauthToken/_baseSchema";
|
|
import * as BaseOauthUser from "./OauthUser/_baseSchema";
|
|
import * as BaseOauthUserAuthorization from "./OauthUserAuthorization/_baseSchema";
|
|
import * as BaseParasite from "./Parasite/_baseSchema";
|
|
import * as BasePassport from "./Passport/_baseSchema";
|
|
import * as BasePlatform from "./Platform/_baseSchema";
|
|
import * as BaseReadRemark from "./ReadRemark/_baseSchema";
|
|
import * as BaseSession from "./Session/_baseSchema";
|
|
import * as BaseSessionMessage from "./SessionMessage/_baseSchema";
|
|
import * as BaseSmsTemplate from "./SmsTemplate/_baseSchema";
|
|
import * as BaseStation from "./Station/_baseSchema";
|
|
import * as BaseSubscription from "./Subscription/_baseSchema";
|
|
import * as BaseSubway from "./Subway/_baseSchema";
|
|
import * as BaseSubwayStation from "./SubwayStation/_baseSchema";
|
|
import * as BaseSystem from "./System/_baseSchema";
|
|
import * as BaseToDo from "./ToDo/_baseSchema";
|
|
import * as BaseToken from "./Token/_baseSchema";
|
|
import * as BaseUserSystem from "./UserSystem/_baseSchema";
|
|
import * as BaseUserWechatPublicTag from "./UserWechatPublicTag/_baseSchema";
|
|
import * as BaseWechatLogin from "./WechatLogin/_baseSchema";
|
|
import * as BaseWechatMenu from "./WechatMenu/_baseSchema";
|
|
import * as BaseWechatMpJump from "./WechatMpJump/_baseSchema";
|
|
import * as BaseWechatPublicAutoReply from "./WechatPublicAutoReply/_baseSchema";
|
|
import * as BaseWechatPublicTag from "./WechatPublicTag/_baseSchema";
|
|
import * as BaseWechatQrCode from "./WechatQrCode/_baseSchema";
|
|
import * as BaseWechatTemplate from "./WechatTemplate/_baseSchema";
|
|
import * as BaseWechatUser from "./WechatUser/_baseSchema";
|
|
import * as BaseAbstractPayAccount from "./AbstractPayAccount/_baseSchema";
|
|
import * as BaseAbstractPayProduct from "./AbstractPayProduct/_baseSchema";
|
|
import * as BaseAbstractShipAccount from "./AbstractShipAccount/_baseSchema";
|
|
import * as BaseAccount from "./Account/_baseSchema";
|
|
import * as BaseAccountOper from "./AccountOper/_baseSchema";
|
|
import * as BaseAliPay from "./AliPay/_baseSchema";
|
|
import * as BaseApAccount from "./ApAccount/_baseSchema";
|
|
import * as BaseApProduct from "./ApProduct/_baseSchema";
|
|
import * as BaseDeposit from "./Deposit/_baseSchema";
|
|
import * as BaseOfflineAccount from "./OfflineAccount/_baseSchema";
|
|
import * as BaseOrder from "./Order/_baseSchema";
|
|
import * as BasePay from "./Pay/_baseSchema";
|
|
import * as BaseRefund from "./Refund/_baseSchema";
|
|
import * as BaseSettlement from "./Settlement/_baseSchema";
|
|
import * as BaseSettlePlan from "./SettlePlan/_baseSchema";
|
|
import * as BaseShip from "./Ship/_baseSchema";
|
|
import * as BaseShipCompany from "./ShipCompany/_baseSchema";
|
|
import * as BaseShipOrder from "./ShipOrder/_baseSchema";
|
|
import * as BaseShipService from "./ShipService/_baseSchema";
|
|
import * as BaseShipServiceSystem from "./ShipServiceSystem/_baseSchema";
|
|
import * as BaseSysAccountMove from "./SysAccountMove/_baseSchema";
|
|
import * as BaseSysAccountOper from "./SysAccountOper/_baseSchema";
|
|
import * as BaseWechatMpShip from "./WechatMpShip/_baseSchema";
|
|
import * as BaseWechatPay from "./WechatPay/_baseSchema";
|
|
import * as BaseWithdraw from "./Withdraw/_baseSchema";
|
|
import * as BaseWithdrawAccount from "./WithdrawAccount/_baseSchema";
|
|
import * as BaseWithdrawChannel from "./WithdrawChannel/_baseSchema";
|
|
import * as BaseWithdrawTransfer from "./WithdrawTransfer/_baseSchema";
|
|
import * as BaseWpAccount from "./WpAccount/_baseSchema";
|
|
import * as BaseWpProduct from "./WpProduct/_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"]>;
|
|
path?: OakOperation<"create", Path["CreateOperationData"]> | OakOperation<BasePath.OpUpdateAction, Path["UpdateOperationData"], Path["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"]>;
|
|
path?: OakOperation<"create", Path["CreateOperationData"]> | OakOperation<BasePath.OpUpdateAction, Path["UpdateOperationData"], Path["Filter"]> | OakOperation<"remove", Path["RemoveOperationData"], Path["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 & {
|
|
actionAuth$path?: (OakOperation<"create", Omit<ActionAuth["CreateOperationData"], "path"> | Omit<ActionAuth["CreateOperationData"], "path">[]> | OakOperation<BaseActionAuth.OpUpdateAction, Omit<ActionAuth["UpdateOperationData"], "path">, ActionAuth["Filter"]>)[];
|
|
relationAuth$path?: (OakOperation<"create", Omit<RelationAuth["CreateOperationData"], "path"> | Omit<RelationAuth["CreateOperationData"], "path">[]> | OakOperation<BaseRelationAuth.OpUpdateAction, Omit<RelationAuth["UpdateOperationData"], "path">, RelationAuth["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Path["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Path["CreateOperationData"]>>;
|
|
Create: Path["CreateSingle"] | Path["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BasePath.OpSchema & {
|
|
actionAuth$path?: (OakOperation<"create", Omit<ActionAuth["CreateOperationData"], "path"> | Omit<ActionAuth["CreateOperationData"], "path">[]> | OakOperation<BaseActionAuth.OpUpdateAction, Omit<ActionAuth["UpdateOperationData"], "path">, ActionAuth["Filter"]> | OakOperation<"remove", ActionAuth["RemoveOperationData"], ActionAuth["Filter"]>)[];
|
|
relationAuth$path?: (OakOperation<"create", Omit<RelationAuth["CreateOperationData"], "path"> | Omit<RelationAuth["CreateOperationData"], "path">[]> | OakOperation<BaseRelationAuth.OpUpdateAction, Omit<RelationAuth["UpdateOperationData"], "path">, RelationAuth["Filter"]> | OakOperation<"remove", RelationAuth["RemoveOperationData"], RelationAuth["Filter"]>)[];
|
|
}>;
|
|
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 & {
|
|
platform?: Platform["Schema"];
|
|
session?: Session["Schema"];
|
|
toDo?: ToDo["Schema"];
|
|
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 & {
|
|
platform?: Platform["Projection"];
|
|
session?: Session["Projection"];
|
|
toDo?: ToDo["Projection"];
|
|
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 & {
|
|
platform: MakeFilter<Platform["FilterUnit"]>;
|
|
session: MakeFilter<Session["FilterUnit"]>;
|
|
toDo: MakeFilter<ToDo["FilterUnit"]>;
|
|
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 | {
|
|
platform: Platform["SortAttr"];
|
|
session: Session["SortAttr"];
|
|
toDo: ToDo["SortAttr"];
|
|
}>;
|
|
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 & {
|
|
platform?: OakOperation<"create", Platform["CreateOperationData"]> | OakOperation<BasePlatform.OpUpdateAction, Platform["UpdateOperationData"], Platform["Filter"]>;
|
|
session?: OakOperation<"create", Session["CreateOperationData"]> | OakOperation<BaseSession.OpUpdateAction, Session["UpdateOperationData"], Session["Filter"]>;
|
|
toDo?: OakOperation<"create", ToDo["CreateOperationData"]> | OakOperation<BaseToDo.OpUpdateAction, ToDo["UpdateOperationData"], ToDo["Filter"]>;
|
|
actionAuth$relation?: (OakOperation<"create", Omit<ActionAuth["CreateOperationData"], "relation"> | Omit<ActionAuth["CreateOperationData"], "relation">[]> | OakOperation<BaseActionAuth.OpUpdateAction, Omit<ActionAuth["UpdateOperationData"], "relation">, ActionAuth["Filter"]>)[];
|
|
relationAuth$sourceRelation?: (OakOperation<"create", Omit<RelationAuth["CreateOperationData"], "sourceRelation"> | Omit<RelationAuth["CreateOperationData"], "sourceRelation">[]> | OakOperation<BaseRelationAuth.OpUpdateAction, Omit<RelationAuth["UpdateOperationData"], "sourceRelation">, RelationAuth["Filter"]>)[];
|
|
relationAuth$destRelation?: (OakOperation<"create", Omit<RelationAuth["CreateOperationData"], "destRelation"> | Omit<RelationAuth["CreateOperationData"], "destRelation">[]> | OakOperation<BaseRelationAuth.OpUpdateAction, Omit<RelationAuth["UpdateOperationData"], "destRelation">, RelationAuth["Filter"]>)[];
|
|
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 & {
|
|
platform?: OakOperation<"create", Platform["CreateOperationData"]> | OakOperation<BasePlatform.OpUpdateAction, Platform["UpdateOperationData"], Platform["Filter"]> | OakOperation<"remove", Platform["RemoveOperationData"], Platform["Filter"]>;
|
|
session?: OakOperation<"create", Session["CreateOperationData"]> | OakOperation<BaseSession.OpUpdateAction, Session["UpdateOperationData"], Session["Filter"]> | OakOperation<"remove", Session["RemoveOperationData"], Session["Filter"]>;
|
|
toDo?: OakOperation<"create", ToDo["CreateOperationData"]> | OakOperation<BaseToDo.OpUpdateAction, ToDo["UpdateOperationData"], ToDo["Filter"]> | OakOperation<"remove", ToDo["RemoveOperationData"], ToDo["Filter"]>;
|
|
actionAuth$relation?: (OakOperation<"create", Omit<ActionAuth["CreateOperationData"], "relation"> | Omit<ActionAuth["CreateOperationData"], "relation">[]> | OakOperation<BaseActionAuth.OpUpdateAction, Omit<ActionAuth["UpdateOperationData"], "relation">, ActionAuth["Filter"]> | OakOperation<"remove", ActionAuth["RemoveOperationData"], ActionAuth["Filter"]>)[];
|
|
relationAuth$sourceRelation?: (OakOperation<"create", Omit<RelationAuth["CreateOperationData"], "sourceRelation"> | Omit<RelationAuth["CreateOperationData"], "sourceRelation">[]> | OakOperation<BaseRelationAuth.OpUpdateAction, Omit<RelationAuth["UpdateOperationData"], "sourceRelation">, RelationAuth["Filter"]> | OakOperation<"remove", RelationAuth["RemoveOperationData"], RelationAuth["Filter"]>)[];
|
|
relationAuth$destRelation?: (OakOperation<"create", Omit<RelationAuth["CreateOperationData"], "destRelation"> | Omit<RelationAuth["CreateOperationData"], "destRelation">[]> | OakOperation<BaseRelationAuth.OpUpdateAction, Omit<RelationAuth["UpdateOperationData"], "destRelation">, RelationAuth["Filter"]> | OakOperation<"remove", RelationAuth["RemoveOperationData"], RelationAuth["Filter"]>)[];
|
|
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"]>;
|
|
path?: OakOperation<"create", Path["CreateOperationData"]> | OakOperation<BasePath.OpUpdateAction, Path["UpdateOperationData"], Path["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"]>;
|
|
path?: OakOperation<"create", Path["CreateOperationData"]> | OakOperation<BasePath.OpUpdateAction, Path["UpdateOperationData"], Path["Filter"]> | OakOperation<"remove", Path["RemoveOperationData"], Path["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">>;
|
|
changePasswordTemp$user?: Array<Omit<ChangePasswordTemp["Schema"], "user">>;
|
|
email$user?: Array<Omit<Email["Schema"], "user">>;
|
|
loginName$user?: Array<Omit<LoginName["Schema"], "user">>;
|
|
message$user?: Array<Omit<Message["Schema"], "user">>;
|
|
mobile$user?: Array<Omit<Mobile["Schema"], "user">>;
|
|
oauthAuthorizationCode$user?: Array<Omit<OauthAuthorizationCode["Schema"], "user">>;
|
|
oauthState$user?: Array<Omit<OauthState["Schema"], "user">>;
|
|
oauthToken$user?: Array<Omit<OauthToken["Schema"], "user">>;
|
|
oauthUser$user?: Array<Omit<OauthUser["Schema"], "user">>;
|
|
oauthUserAuthorization$user?: Array<Omit<OauthUserAuthorization["Schema"], "user">>;
|
|
parasite$user?: Array<Omit<Parasite["Schema"], "user">>;
|
|
readRemark$user?: Array<Omit<ReadRemark["Schema"], "user">>;
|
|
session$user?: Array<Omit<Session["Schema"], "user">>;
|
|
sessionMessage$user?: Array<Omit<SessionMessage["Schema"], "user">>;
|
|
token$user?: Array<Omit<Token["Schema"], "user">>;
|
|
token$player?: Array<Omit<Token["Schema"], "player">>;
|
|
userEntityGrant$granter?: Array<Omit<UserEntityGrant["Schema"], "granter">>;
|
|
userSystem$user?: Array<Omit<UserSystem["Schema"], "user">>;
|
|
wechatLogin$user?: Array<Omit<WechatLogin["Schema"], "user">>;
|
|
wechatUser$user?: Array<Omit<WechatUser["Schema"], "user">>;
|
|
deposit$creator?: Array<Omit<Deposit["Schema"], "creator">>;
|
|
order$creator?: Array<Omit<Order["Schema"], "creator">>;
|
|
pay$creator?: Array<Omit<Pay["Schema"], "creator">>;
|
|
refund$creator?: Array<Omit<Refund["Schema"], "creator">>;
|
|
sysAccountMove$operator?: Array<Omit<SysAccountMove["Schema"], "operator">>;
|
|
withdraw$creator?: Array<Omit<Withdraw["Schema"], "creator">>;
|
|
withdrawTransfer$operator?: Array<Omit<WithdrawTransfer["Schema"], "operator">>;
|
|
withdrawTransfer$creator?: Array<Omit<WithdrawTransfer["Schema"], "creator">>;
|
|
extraFile$entity?: Array<Omit<ExtraFile["Schema"], "entity">>;
|
|
wechatQrCode$entity?: Array<Omit<WechatQrCode["Schema"], "entity">>;
|
|
address$entity?: Array<Omit<Address["Schema"], "entity">>;
|
|
account$entity?: Array<Omit<Account["Schema"], "entity">>;
|
|
withdrawAccount$entity?: Array<Omit<WithdrawAccount["Schema"], "entity">>;
|
|
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">>;
|
|
changePasswordTemp$user$$aggr?: AggregationResult<Omit<ChangePasswordTemp["Schema"], "user">>;
|
|
email$user$$aggr?: AggregationResult<Omit<Email["Schema"], "user">>;
|
|
loginName$user$$aggr?: AggregationResult<Omit<LoginName["Schema"], "user">>;
|
|
message$user$$aggr?: AggregationResult<Omit<Message["Schema"], "user">>;
|
|
mobile$user$$aggr?: AggregationResult<Omit<Mobile["Schema"], "user">>;
|
|
oauthAuthorizationCode$user$$aggr?: AggregationResult<Omit<OauthAuthorizationCode["Schema"], "user">>;
|
|
oauthState$user$$aggr?: AggregationResult<Omit<OauthState["Schema"], "user">>;
|
|
oauthToken$user$$aggr?: AggregationResult<Omit<OauthToken["Schema"], "user">>;
|
|
oauthUser$user$$aggr?: AggregationResult<Omit<OauthUser["Schema"], "user">>;
|
|
oauthUserAuthorization$user$$aggr?: AggregationResult<Omit<OauthUserAuthorization["Schema"], "user">>;
|
|
parasite$user$$aggr?: AggregationResult<Omit<Parasite["Schema"], "user">>;
|
|
readRemark$user$$aggr?: AggregationResult<Omit<ReadRemark["Schema"], "user">>;
|
|
session$user$$aggr?: AggregationResult<Omit<Session["Schema"], "user">>;
|
|
sessionMessage$user$$aggr?: AggregationResult<Omit<SessionMessage["Schema"], "user">>;
|
|
token$user$$aggr?: AggregationResult<Omit<Token["Schema"], "user">>;
|
|
token$player$$aggr?: AggregationResult<Omit<Token["Schema"], "player">>;
|
|
userEntityGrant$granter$$aggr?: AggregationResult<Omit<UserEntityGrant["Schema"], "granter">>;
|
|
userSystem$user$$aggr?: AggregationResult<Omit<UserSystem["Schema"], "user">>;
|
|
wechatLogin$user$$aggr?: AggregationResult<Omit<WechatLogin["Schema"], "user">>;
|
|
wechatUser$user$$aggr?: AggregationResult<Omit<WechatUser["Schema"], "user">>;
|
|
deposit$creator$$aggr?: AggregationResult<Omit<Deposit["Schema"], "creator">>;
|
|
order$creator$$aggr?: AggregationResult<Omit<Order["Schema"], "creator">>;
|
|
pay$creator$$aggr?: AggregationResult<Omit<Pay["Schema"], "creator">>;
|
|
refund$creator$$aggr?: AggregationResult<Omit<Refund["Schema"], "creator">>;
|
|
sysAccountMove$operator$$aggr?: AggregationResult<Omit<SysAccountMove["Schema"], "operator">>;
|
|
withdraw$creator$$aggr?: AggregationResult<Omit<Withdraw["Schema"], "creator">>;
|
|
withdrawTransfer$operator$$aggr?: AggregationResult<Omit<WithdrawTransfer["Schema"], "operator">>;
|
|
withdrawTransfer$creator$$aggr?: AggregationResult<Omit<WithdrawTransfer["Schema"], "creator">>;
|
|
extraFile$entity$$aggr?: AggregationResult<Omit<ExtraFile["Schema"], "entity">>;
|
|
wechatQrCode$entity$$aggr?: AggregationResult<Omit<WechatQrCode["Schema"], "entity">>;
|
|
address$entity$$aggr?: AggregationResult<Omit<Address["Schema"], "entity">>;
|
|
account$entity$$aggr?: AggregationResult<Omit<Account["Schema"], "entity">>;
|
|
withdrawAccount$entity$$aggr?: AggregationResult<Omit<WithdrawAccount["Schema"], "entity">>;
|
|
};
|
|
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";
|
|
};
|
|
changePasswordTemp$user?: OakSelection<"select", Omit<ChangePasswordTemp["Projection"], "user">, Omit<ChangePasswordTemp["Filter"], "user">, ChangePasswordTemp["Sorter"]> & {
|
|
$entity: "changePasswordTemp";
|
|
};
|
|
changePasswordTemp$user$$aggr?: DeduceAggregation<Omit<ChangePasswordTemp["Projection"], "user">, Omit<ChangePasswordTemp["Filter"], "user">, ChangePasswordTemp["Sorter"]> & {
|
|
$entity: "changePasswordTemp";
|
|
};
|
|
email$user?: OakSelection<"select", Omit<Email["Projection"], "user">, Omit<Email["Filter"], "user">, Email["Sorter"]> & {
|
|
$entity: "email";
|
|
};
|
|
email$user$$aggr?: DeduceAggregation<Omit<Email["Projection"], "user">, Omit<Email["Filter"], "user">, Email["Sorter"]> & {
|
|
$entity: "email";
|
|
};
|
|
loginName$user?: OakSelection<"select", Omit<LoginName["Projection"], "user">, Omit<LoginName["Filter"], "user">, LoginName["Sorter"]> & {
|
|
$entity: "loginName";
|
|
};
|
|
loginName$user$$aggr?: DeduceAggregation<Omit<LoginName["Projection"], "user">, Omit<LoginName["Filter"], "user">, LoginName["Sorter"]> & {
|
|
$entity: "loginName";
|
|
};
|
|
message$user?: OakSelection<"select", Omit<Message["Projection"], "user">, Omit<Message["Filter"], "user">, Message["Sorter"]> & {
|
|
$entity: "message";
|
|
};
|
|
message$user$$aggr?: DeduceAggregation<Omit<Message["Projection"], "user">, Omit<Message["Filter"], "user">, Message["Sorter"]> & {
|
|
$entity: "message";
|
|
};
|
|
mobile$user?: OakSelection<"select", Omit<Mobile["Projection"], "user">, Omit<Mobile["Filter"], "user">, Mobile["Sorter"]> & {
|
|
$entity: "mobile";
|
|
};
|
|
mobile$user$$aggr?: DeduceAggregation<Omit<Mobile["Projection"], "user">, Omit<Mobile["Filter"], "user">, Mobile["Sorter"]> & {
|
|
$entity: "mobile";
|
|
};
|
|
oauthAuthorizationCode$user?: OakSelection<"select", Omit<OauthAuthorizationCode["Projection"], "user">, Omit<OauthAuthorizationCode["Filter"], "user">, OauthAuthorizationCode["Sorter"]> & {
|
|
$entity: "oauthAuthorizationCode";
|
|
};
|
|
oauthAuthorizationCode$user$$aggr?: DeduceAggregation<Omit<OauthAuthorizationCode["Projection"], "user">, Omit<OauthAuthorizationCode["Filter"], "user">, OauthAuthorizationCode["Sorter"]> & {
|
|
$entity: "oauthAuthorizationCode";
|
|
};
|
|
oauthState$user?: OakSelection<"select", Omit<OauthState["Projection"], "user">, Omit<OauthState["Filter"], "user">, OauthState["Sorter"]> & {
|
|
$entity: "oauthState";
|
|
};
|
|
oauthState$user$$aggr?: DeduceAggregation<Omit<OauthState["Projection"], "user">, Omit<OauthState["Filter"], "user">, OauthState["Sorter"]> & {
|
|
$entity: "oauthState";
|
|
};
|
|
oauthToken$user?: OakSelection<"select", Omit<OauthToken["Projection"], "user">, Omit<OauthToken["Filter"], "user">, OauthToken["Sorter"]> & {
|
|
$entity: "oauthToken";
|
|
};
|
|
oauthToken$user$$aggr?: DeduceAggregation<Omit<OauthToken["Projection"], "user">, Omit<OauthToken["Filter"], "user">, OauthToken["Sorter"]> & {
|
|
$entity: "oauthToken";
|
|
};
|
|
oauthUser$user?: OakSelection<"select", Omit<OauthUser["Projection"], "user">, Omit<OauthUser["Filter"], "user">, OauthUser["Sorter"]> & {
|
|
$entity: "oauthUser";
|
|
};
|
|
oauthUser$user$$aggr?: DeduceAggregation<Omit<OauthUser["Projection"], "user">, Omit<OauthUser["Filter"], "user">, OauthUser["Sorter"]> & {
|
|
$entity: "oauthUser";
|
|
};
|
|
oauthUserAuthorization$user?: OakSelection<"select", Omit<OauthUserAuthorization["Projection"], "user">, Omit<OauthUserAuthorization["Filter"], "user">, OauthUserAuthorization["Sorter"]> & {
|
|
$entity: "oauthUserAuthorization";
|
|
};
|
|
oauthUserAuthorization$user$$aggr?: DeduceAggregation<Omit<OauthUserAuthorization["Projection"], "user">, Omit<OauthUserAuthorization["Filter"], "user">, OauthUserAuthorization["Sorter"]> & {
|
|
$entity: "oauthUserAuthorization";
|
|
};
|
|
parasite$user?: OakSelection<"select", Omit<Parasite["Projection"], "user">, Omit<Parasite["Filter"], "user">, Parasite["Sorter"]> & {
|
|
$entity: "parasite";
|
|
};
|
|
parasite$user$$aggr?: DeduceAggregation<Omit<Parasite["Projection"], "user">, Omit<Parasite["Filter"], "user">, Parasite["Sorter"]> & {
|
|
$entity: "parasite";
|
|
};
|
|
readRemark$user?: OakSelection<"select", Omit<ReadRemark["Projection"], "user">, Omit<ReadRemark["Filter"], "user">, ReadRemark["Sorter"]> & {
|
|
$entity: "readRemark";
|
|
};
|
|
readRemark$user$$aggr?: DeduceAggregation<Omit<ReadRemark["Projection"], "user">, Omit<ReadRemark["Filter"], "user">, ReadRemark["Sorter"]> & {
|
|
$entity: "readRemark";
|
|
};
|
|
session$user?: OakSelection<"select", Omit<Session["Projection"], "user">, Omit<Session["Filter"], "user">, Session["Sorter"]> & {
|
|
$entity: "session";
|
|
};
|
|
session$user$$aggr?: DeduceAggregation<Omit<Session["Projection"], "user">, Omit<Session["Filter"], "user">, Session["Sorter"]> & {
|
|
$entity: "session";
|
|
};
|
|
sessionMessage$user?: OakSelection<"select", Omit<SessionMessage["Projection"], "user">, Omit<SessionMessage["Filter"], "user">, SessionMessage["Sorter"]> & {
|
|
$entity: "sessionMessage";
|
|
};
|
|
sessionMessage$user$$aggr?: DeduceAggregation<Omit<SessionMessage["Projection"], "user">, Omit<SessionMessage["Filter"], "user">, SessionMessage["Sorter"]> & {
|
|
$entity: "sessionMessage";
|
|
};
|
|
token$user?: OakSelection<"select", Omit<Token["Projection"], "user">, Omit<Token["Filter"], "user">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$user$$aggr?: DeduceAggregation<Omit<Token["Projection"], "user">, Omit<Token["Filter"], "user">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$player?: OakSelection<"select", Omit<Token["Projection"], "user">, Omit<Token["Filter"], "user">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$player$$aggr?: DeduceAggregation<Omit<Token["Projection"], "user">, Omit<Token["Filter"], "user">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
userEntityGrant$granter?: OakSelection<"select", Omit<UserEntityGrant["Projection"], "user">, Omit<UserEntityGrant["Filter"], "user">, UserEntityGrant["Sorter"]> & {
|
|
$entity: "userEntityGrant";
|
|
};
|
|
userEntityGrant$granter$$aggr?: DeduceAggregation<Omit<UserEntityGrant["Projection"], "user">, Omit<UserEntityGrant["Filter"], "user">, UserEntityGrant["Sorter"]> & {
|
|
$entity: "userEntityGrant";
|
|
};
|
|
userSystem$user?: OakSelection<"select", Omit<UserSystem["Projection"], "user">, Omit<UserSystem["Filter"], "user">, UserSystem["Sorter"]> & {
|
|
$entity: "userSystem";
|
|
};
|
|
userSystem$user$$aggr?: DeduceAggregation<Omit<UserSystem["Projection"], "user">, Omit<UserSystem["Filter"], "user">, UserSystem["Sorter"]> & {
|
|
$entity: "userSystem";
|
|
};
|
|
wechatLogin$user?: OakSelection<"select", Omit<WechatLogin["Projection"], "user">, Omit<WechatLogin["Filter"], "user">, WechatLogin["Sorter"]> & {
|
|
$entity: "wechatLogin";
|
|
};
|
|
wechatLogin$user$$aggr?: DeduceAggregation<Omit<WechatLogin["Projection"], "user">, Omit<WechatLogin["Filter"], "user">, WechatLogin["Sorter"]> & {
|
|
$entity: "wechatLogin";
|
|
};
|
|
wechatUser$user?: OakSelection<"select", Omit<WechatUser["Projection"], "user">, Omit<WechatUser["Filter"], "user">, WechatUser["Sorter"]> & {
|
|
$entity: "wechatUser";
|
|
};
|
|
wechatUser$user$$aggr?: DeduceAggregation<Omit<WechatUser["Projection"], "user">, Omit<WechatUser["Filter"], "user">, WechatUser["Sorter"]> & {
|
|
$entity: "wechatUser";
|
|
};
|
|
deposit$creator?: OakSelection<"select", Omit<Deposit["Projection"], "user">, Omit<Deposit["Filter"], "user">, Deposit["Sorter"]> & {
|
|
$entity: "deposit";
|
|
};
|
|
deposit$creator$$aggr?: DeduceAggregation<Omit<Deposit["Projection"], "user">, Omit<Deposit["Filter"], "user">, Deposit["Sorter"]> & {
|
|
$entity: "deposit";
|
|
};
|
|
order$creator?: OakSelection<"select", Omit<Order["Projection"], "user">, Omit<Order["Filter"], "user">, Order["Sorter"]> & {
|
|
$entity: "order";
|
|
};
|
|
order$creator$$aggr?: DeduceAggregation<Omit<Order["Projection"], "user">, Omit<Order["Filter"], "user">, Order["Sorter"]> & {
|
|
$entity: "order";
|
|
};
|
|
pay$creator?: OakSelection<"select", Omit<Pay["Projection"], "user">, Omit<Pay["Filter"], "user">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
pay$creator$$aggr?: DeduceAggregation<Omit<Pay["Projection"], "user">, Omit<Pay["Filter"], "user">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
refund$creator?: OakSelection<"select", Omit<Refund["Projection"], "user">, Omit<Refund["Filter"], "user">, Refund["Sorter"]> & {
|
|
$entity: "refund";
|
|
};
|
|
refund$creator$$aggr?: DeduceAggregation<Omit<Refund["Projection"], "user">, Omit<Refund["Filter"], "user">, Refund["Sorter"]> & {
|
|
$entity: "refund";
|
|
};
|
|
sysAccountMove$operator?: OakSelection<"select", Omit<SysAccountMove["Projection"], "user">, Omit<SysAccountMove["Filter"], "user">, SysAccountMove["Sorter"]> & {
|
|
$entity: "sysAccountMove";
|
|
};
|
|
sysAccountMove$operator$$aggr?: DeduceAggregation<Omit<SysAccountMove["Projection"], "user">, Omit<SysAccountMove["Filter"], "user">, SysAccountMove["Sorter"]> & {
|
|
$entity: "sysAccountMove";
|
|
};
|
|
withdraw$creator?: OakSelection<"select", Omit<Withdraw["Projection"], "user">, Omit<Withdraw["Filter"], "user">, Withdraw["Sorter"]> & {
|
|
$entity: "withdraw";
|
|
};
|
|
withdraw$creator$$aggr?: DeduceAggregation<Omit<Withdraw["Projection"], "user">, Omit<Withdraw["Filter"], "user">, Withdraw["Sorter"]> & {
|
|
$entity: "withdraw";
|
|
};
|
|
withdrawTransfer$operator?: OakSelection<"select", Omit<WithdrawTransfer["Projection"], "user">, Omit<WithdrawTransfer["Filter"], "user">, WithdrawTransfer["Sorter"]> & {
|
|
$entity: "withdrawTransfer";
|
|
};
|
|
withdrawTransfer$operator$$aggr?: DeduceAggregation<Omit<WithdrawTransfer["Projection"], "user">, Omit<WithdrawTransfer["Filter"], "user">, WithdrawTransfer["Sorter"]> & {
|
|
$entity: "withdrawTransfer";
|
|
};
|
|
withdrawTransfer$creator?: OakSelection<"select", Omit<WithdrawTransfer["Projection"], "user">, Omit<WithdrawTransfer["Filter"], "user">, WithdrawTransfer["Sorter"]> & {
|
|
$entity: "withdrawTransfer";
|
|
};
|
|
withdrawTransfer$creator$$aggr?: DeduceAggregation<Omit<WithdrawTransfer["Projection"], "user">, Omit<WithdrawTransfer["Filter"], "user">, WithdrawTransfer["Sorter"]> & {
|
|
$entity: "withdrawTransfer";
|
|
};
|
|
extraFile$entity?: OakSelection<"select", Omit<ExtraFile["Projection"], "user">, Omit<ExtraFile["Filter"], "user">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
extraFile$entity$$aggr?: DeduceAggregation<Omit<ExtraFile["Projection"], "user">, Omit<ExtraFile["Filter"], "user">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
wechatQrCode$entity?: OakSelection<"select", Omit<WechatQrCode["Projection"], "user">, Omit<WechatQrCode["Filter"], "user">, WechatQrCode["Sorter"]> & {
|
|
$entity: "wechatQrCode";
|
|
};
|
|
wechatQrCode$entity$$aggr?: DeduceAggregation<Omit<WechatQrCode["Projection"], "user">, Omit<WechatQrCode["Filter"], "user">, WechatQrCode["Sorter"]> & {
|
|
$entity: "wechatQrCode";
|
|
};
|
|
address$entity?: OakSelection<"select", Omit<Address["Projection"], "user">, Omit<Address["Filter"], "user">, Address["Sorter"]> & {
|
|
$entity: "address";
|
|
};
|
|
address$entity$$aggr?: DeduceAggregation<Omit<Address["Projection"], "user">, Omit<Address["Filter"], "user">, Address["Sorter"]> & {
|
|
$entity: "address";
|
|
};
|
|
account$entity?: OakSelection<"select", Omit<Account["Projection"], "user">, Omit<Account["Filter"], "user">, Account["Sorter"]> & {
|
|
$entity: "account";
|
|
};
|
|
account$entity$$aggr?: DeduceAggregation<Omit<Account["Projection"], "user">, Omit<Account["Filter"], "user">, Account["Sorter"]> & {
|
|
$entity: "account";
|
|
};
|
|
withdrawAccount$entity?: OakSelection<"select", Omit<WithdrawAccount["Projection"], "user">, Omit<WithdrawAccount["Filter"], "user">, WithdrawAccount["Sorter"]> & {
|
|
$entity: "withdrawAccount";
|
|
};
|
|
withdrawAccount$entity$$aggr?: DeduceAggregation<Omit<WithdrawAccount["Projection"], "user">, Omit<WithdrawAccount["Filter"], "user">, WithdrawAccount["Sorter"]> & {
|
|
$entity: "withdrawAccount";
|
|
};
|
|
};
|
|
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;
|
|
changePasswordTemp$user: MakeFilter<Omit<ChangePasswordTemp["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
email$user: MakeFilter<Omit<Email["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
loginName$user: MakeFilter<Omit<LoginName["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
message$user: MakeFilter<Omit<Message["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
mobile$user: MakeFilter<Omit<Mobile["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
oauthAuthorizationCode$user: MakeFilter<Omit<OauthAuthorizationCode["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
oauthState$user: MakeFilter<Omit<OauthState["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
oauthToken$user: MakeFilter<Omit<OauthToken["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
oauthUser$user: MakeFilter<Omit<OauthUser["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
oauthUserAuthorization$user: MakeFilter<Omit<OauthUserAuthorization["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
parasite$user: MakeFilter<Omit<Parasite["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
readRemark$user: MakeFilter<Omit<ReadRemark["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
session$user: MakeFilter<Omit<Session["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
sessionMessage$user: MakeFilter<Omit<SessionMessage["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
token$user: MakeFilter<Omit<Token["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
token$player: MakeFilter<Omit<Token["FilterUnit"], "player">> & SubQueryPredicateMetadata;
|
|
userEntityGrant$granter: MakeFilter<Omit<UserEntityGrant["FilterUnit"], "granter">> & SubQueryPredicateMetadata;
|
|
userSystem$user: MakeFilter<Omit<UserSystem["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
wechatLogin$user: MakeFilter<Omit<WechatLogin["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
wechatUser$user: MakeFilter<Omit<WechatUser["FilterUnit"], "user">> & SubQueryPredicateMetadata;
|
|
deposit$creator: MakeFilter<Omit<Deposit["FilterUnit"], "creator">> & SubQueryPredicateMetadata;
|
|
order$creator: MakeFilter<Omit<Order["FilterUnit"], "creator">> & SubQueryPredicateMetadata;
|
|
pay$creator: MakeFilter<Omit<Pay["FilterUnit"], "creator">> & SubQueryPredicateMetadata;
|
|
refund$creator: MakeFilter<Omit<Refund["FilterUnit"], "creator">> & SubQueryPredicateMetadata;
|
|
sysAccountMove$operator: MakeFilter<Omit<SysAccountMove["FilterUnit"], "operator">> & SubQueryPredicateMetadata;
|
|
withdraw$creator: MakeFilter<Omit<Withdraw["FilterUnit"], "creator">> & SubQueryPredicateMetadata;
|
|
withdrawTransfer$operator: MakeFilter<Omit<WithdrawTransfer["FilterUnit"], "operator">> & SubQueryPredicateMetadata;
|
|
withdrawTransfer$creator: MakeFilter<Omit<WithdrawTransfer["FilterUnit"], "creator">> & SubQueryPredicateMetadata;
|
|
extraFile$entity: MakeFilter<Omit<ExtraFile["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
wechatQrCode$entity: MakeFilter<Omit<WechatQrCode["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
address$entity: MakeFilter<Omit<Address["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
account$entity: MakeFilter<Omit<Account["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
withdrawAccount$entity: MakeFilter<Omit<WithdrawAccount["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
} & FulltextFilter;
|
|
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"]>)[];
|
|
changePasswordTemp$user?: (OakOperation<"create", Omit<ChangePasswordTemp["CreateOperationData"], "user"> | Omit<ChangePasswordTemp["CreateOperationData"], "user">[]> | OakOperation<BaseChangePasswordTemp.OpUpdateAction, Omit<ChangePasswordTemp["UpdateOperationData"], "user">, ChangePasswordTemp["Filter"]>)[];
|
|
email$user?: (OakOperation<"create", Omit<Email["CreateOperationData"], "user"> | Omit<Email["CreateOperationData"], "user">[]> | OakOperation<BaseEmail.OpUpdateAction, Omit<Email["UpdateOperationData"], "user">, Email["Filter"]>)[];
|
|
loginName$user?: (OakOperation<"create", Omit<LoginName["CreateOperationData"], "user"> | Omit<LoginName["CreateOperationData"], "user">[]> | OakOperation<BaseLoginName.OpUpdateAction, Omit<LoginName["UpdateOperationData"], "user">, LoginName["Filter"]>)[];
|
|
message$user?: (OakOperation<"create", Omit<Message["CreateOperationData"], "user"> | Omit<Message["CreateOperationData"], "user">[]> | OakOperation<BaseMessage.OpUpdateAction, Omit<Message["UpdateOperationData"], "user">, Message["Filter"]>)[];
|
|
mobile$user?: (OakOperation<"create", Omit<Mobile["CreateOperationData"], "user"> | Omit<Mobile["CreateOperationData"], "user">[]> | OakOperation<BaseMobile.OpUpdateAction, Omit<Mobile["UpdateOperationData"], "user">, Mobile["Filter"]>)[];
|
|
oauthAuthorizationCode$user?: (OakOperation<"create", Omit<OauthAuthorizationCode["CreateOperationData"], "user"> | Omit<OauthAuthorizationCode["CreateOperationData"], "user">[]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, Omit<OauthAuthorizationCode["UpdateOperationData"], "user">, OauthAuthorizationCode["Filter"]>)[];
|
|
oauthState$user?: (OakOperation<"create", Omit<OauthState["CreateOperationData"], "user"> | Omit<OauthState["CreateOperationData"], "user">[]> | OakOperation<BaseOauthState.OpUpdateAction, Omit<OauthState["UpdateOperationData"], "user">, OauthState["Filter"]>)[];
|
|
oauthToken$user?: (OakOperation<"create", Omit<OauthToken["CreateOperationData"], "user"> | Omit<OauthToken["CreateOperationData"], "user">[]> | OakOperation<BaseOauthToken.OpUpdateAction, Omit<OauthToken["UpdateOperationData"], "user">, OauthToken["Filter"]>)[];
|
|
oauthUser$user?: (OakOperation<"create", Omit<OauthUser["CreateOperationData"], "user"> | Omit<OauthUser["CreateOperationData"], "user">[]> | OakOperation<BaseOauthUser.OpUpdateAction, Omit<OauthUser["UpdateOperationData"], "user">, OauthUser["Filter"]>)[];
|
|
oauthUserAuthorization$user?: (OakOperation<"create", Omit<OauthUserAuthorization["CreateOperationData"], "user"> | Omit<OauthUserAuthorization["CreateOperationData"], "user">[]> | OakOperation<BaseOauthUserAuthorization.OpUpdateAction, Omit<OauthUserAuthorization["UpdateOperationData"], "user">, OauthUserAuthorization["Filter"]>)[];
|
|
parasite$user?: (OakOperation<"create", Omit<Parasite["CreateOperationData"], "user"> | Omit<Parasite["CreateOperationData"], "user">[]> | OakOperation<BaseParasite.OpUpdateAction, Omit<Parasite["UpdateOperationData"], "user">, Parasite["Filter"]>)[];
|
|
readRemark$user?: (OakOperation<"create", Omit<ReadRemark["CreateOperationData"], "user"> | Omit<ReadRemark["CreateOperationData"], "user">[]> | OakOperation<BaseReadRemark.OpUpdateAction, Omit<ReadRemark["UpdateOperationData"], "user">, ReadRemark["Filter"]>)[];
|
|
session$user?: (OakOperation<"create", Omit<Session["CreateOperationData"], "user"> | Omit<Session["CreateOperationData"], "user">[]> | OakOperation<BaseSession.OpUpdateAction, Omit<Session["UpdateOperationData"], "user">, Session["Filter"]>)[];
|
|
sessionMessage$user?: (OakOperation<"create", Omit<SessionMessage["CreateOperationData"], "user"> | Omit<SessionMessage["CreateOperationData"], "user">[]> | OakOperation<BaseSessionMessage.OpUpdateAction, Omit<SessionMessage["UpdateOperationData"], "user">, SessionMessage["Filter"]>)[];
|
|
token$user?: (OakOperation<"create", Omit<Token["CreateOperationData"], "user"> | Omit<Token["CreateOperationData"], "user">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "user">, Token["Filter"]>)[];
|
|
token$player?: (OakOperation<"create", Omit<Token["CreateOperationData"], "player"> | Omit<Token["CreateOperationData"], "player">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "player">, Token["Filter"]>)[];
|
|
userEntityGrant$granter?: (OakOperation<"create", Omit<UserEntityGrant["CreateOperationData"], "granter"> | Omit<UserEntityGrant["CreateOperationData"], "granter">[]> | OakOperation<BaseUserEntityGrant.OpUpdateAction, Omit<UserEntityGrant["UpdateOperationData"], "granter">, UserEntityGrant["Filter"]>)[];
|
|
userSystem$user?: (OakOperation<"create", Omit<UserSystem["CreateOperationData"], "user"> | Omit<UserSystem["CreateOperationData"], "user">[]> | OakOperation<BaseUserSystem.OpUpdateAction, Omit<UserSystem["UpdateOperationData"], "user">, UserSystem["Filter"]>)[];
|
|
wechatLogin$user?: (OakOperation<"create", Omit<WechatLogin["CreateOperationData"], "user"> | Omit<WechatLogin["CreateOperationData"], "user">[]> | OakOperation<BaseWechatLogin.OpUpdateAction, Omit<WechatLogin["UpdateOperationData"], "user">, WechatLogin["Filter"]>)[];
|
|
wechatUser$user?: (OakOperation<"create", Omit<WechatUser["CreateOperationData"], "user"> | Omit<WechatUser["CreateOperationData"], "user">[]> | OakOperation<BaseWechatUser.OpUpdateAction, Omit<WechatUser["UpdateOperationData"], "user">, WechatUser["Filter"]>)[];
|
|
deposit$creator?: (OakOperation<"create", Omit<Deposit["CreateOperationData"], "creator"> | Omit<Deposit["CreateOperationData"], "creator">[]> | OakOperation<BaseDeposit.OpUpdateAction, Omit<Deposit["UpdateOperationData"], "creator">, Deposit["Filter"]>)[];
|
|
order$creator?: (OakOperation<"create", Omit<Order["CreateOperationData"], "creator"> | Omit<Order["CreateOperationData"], "creator">[]> | OakOperation<BaseOrder.OpUpdateAction, Omit<Order["UpdateOperationData"], "creator">, Order["Filter"]>)[];
|
|
pay$creator?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "creator"> | Omit<Pay["CreateOperationData"], "creator">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "creator">, Pay["Filter"]>)[];
|
|
refund$creator?: (OakOperation<"create", Omit<Refund["CreateOperationData"], "creator"> | Omit<Refund["CreateOperationData"], "creator">[]> | OakOperation<BaseRefund.OpUpdateAction, Omit<Refund["UpdateOperationData"], "creator">, Refund["Filter"]>)[];
|
|
sysAccountMove$operator?: OakOperation<"create", Omit<SysAccountMove["CreateOperationData"], "operator"> | Omit<SysAccountMove["CreateOperationData"], "operator">[]>[];
|
|
withdraw$creator?: (OakOperation<"create", Omit<Withdraw["CreateOperationData"], "creator"> | Omit<Withdraw["CreateOperationData"], "creator">[]> | OakOperation<BaseWithdraw.OpUpdateAction, Omit<Withdraw["UpdateOperationData"], "creator">, Withdraw["Filter"]>)[];
|
|
withdrawTransfer$operator?: (OakOperation<"create", Omit<WithdrawTransfer["CreateOperationData"], "operator"> | Omit<WithdrawTransfer["CreateOperationData"], "operator">[]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, Omit<WithdrawTransfer["UpdateOperationData"], "operator">, WithdrawTransfer["Filter"]>)[];
|
|
withdrawTransfer$creator?: (OakOperation<"create", Omit<WithdrawTransfer["CreateOperationData"], "creator"> | Omit<WithdrawTransfer["CreateOperationData"], "creator">[]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, Omit<WithdrawTransfer["UpdateOperationData"], "creator">, WithdrawTransfer["Filter"]>)[];
|
|
extraFile$entity?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "user"> | Omit<ExtraFile["CreateOperationData"], "user">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "user">, ExtraFile["Filter"]>)[];
|
|
wechatQrCode$entity?: (OakOperation<"create", Omit<WechatQrCode["CreateOperationData"], "user"> | Omit<WechatQrCode["CreateOperationData"], "user">[]> | OakOperation<BaseWechatQrCode.OpUpdateAction, Omit<WechatQrCode["UpdateOperationData"], "user">, WechatQrCode["Filter"]>)[];
|
|
address$entity?: (OakOperation<"create", Omit<Address["CreateOperationData"], "user"> | Omit<Address["CreateOperationData"], "user">[]> | OakOperation<BaseAddress.OpUpdateAction, Omit<Address["UpdateOperationData"], "user">, Address["Filter"]>)[];
|
|
account$entity?: (OakOperation<"create", Omit<Account["CreateOperationData"], "user"> | Omit<Account["CreateOperationData"], "user">[]> | OakOperation<BaseAccount.OpUpdateAction, Omit<Account["UpdateOperationData"], "user">, Account["Filter"]>)[];
|
|
withdrawAccount$entity?: (OakOperation<"create", Omit<WithdrawAccount["CreateOperationData"], "user"> | Omit<WithdrawAccount["CreateOperationData"], "user">[]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, Omit<WithdrawAccount["UpdateOperationData"], "user">, WithdrawAccount["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"]>)[];
|
|
changePasswordTemp$user?: (OakOperation<"create", Omit<ChangePasswordTemp["CreateOperationData"], "user"> | Omit<ChangePasswordTemp["CreateOperationData"], "user">[]> | OakOperation<BaseChangePasswordTemp.OpUpdateAction, Omit<ChangePasswordTemp["UpdateOperationData"], "user">, ChangePasswordTemp["Filter"]> | OakOperation<"remove", ChangePasswordTemp["RemoveOperationData"], ChangePasswordTemp["Filter"]>)[];
|
|
email$user?: (OakOperation<"create", Omit<Email["CreateOperationData"], "user"> | Omit<Email["CreateOperationData"], "user">[]> | OakOperation<BaseEmail.OpUpdateAction, Omit<Email["UpdateOperationData"], "user">, Email["Filter"]> | OakOperation<"remove", Email["RemoveOperationData"], Email["Filter"]>)[];
|
|
loginName$user?: (OakOperation<"create", Omit<LoginName["CreateOperationData"], "user"> | Omit<LoginName["CreateOperationData"], "user">[]> | OakOperation<BaseLoginName.OpUpdateAction, Omit<LoginName["UpdateOperationData"], "user">, LoginName["Filter"]> | OakOperation<"remove", LoginName["RemoveOperationData"], LoginName["Filter"]>)[];
|
|
message$user?: (OakOperation<"create", Omit<Message["CreateOperationData"], "user"> | Omit<Message["CreateOperationData"], "user">[]> | OakOperation<BaseMessage.OpUpdateAction, Omit<Message["UpdateOperationData"], "user">, Message["Filter"]> | OakOperation<"remove", Message["RemoveOperationData"], Message["Filter"]>)[];
|
|
mobile$user?: (OakOperation<"create", Omit<Mobile["CreateOperationData"], "user"> | Omit<Mobile["CreateOperationData"], "user">[]> | OakOperation<BaseMobile.OpUpdateAction, Omit<Mobile["UpdateOperationData"], "user">, Mobile["Filter"]> | OakOperation<"remove", Mobile["RemoveOperationData"], Mobile["Filter"]>)[];
|
|
oauthAuthorizationCode$user?: (OakOperation<"create", Omit<OauthAuthorizationCode["CreateOperationData"], "user"> | Omit<OauthAuthorizationCode["CreateOperationData"], "user">[]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, Omit<OauthAuthorizationCode["UpdateOperationData"], "user">, OauthAuthorizationCode["Filter"]> | OakOperation<"remove", OauthAuthorizationCode["RemoveOperationData"], OauthAuthorizationCode["Filter"]>)[];
|
|
oauthState$user?: (OakOperation<"create", Omit<OauthState["CreateOperationData"], "user"> | Omit<OauthState["CreateOperationData"], "user">[]> | OakOperation<BaseOauthState.OpUpdateAction, Omit<OauthState["UpdateOperationData"], "user">, OauthState["Filter"]> | OakOperation<"remove", OauthState["RemoveOperationData"], OauthState["Filter"]>)[];
|
|
oauthToken$user?: (OakOperation<"create", Omit<OauthToken["CreateOperationData"], "user"> | Omit<OauthToken["CreateOperationData"], "user">[]> | OakOperation<BaseOauthToken.OpUpdateAction, Omit<OauthToken["UpdateOperationData"], "user">, OauthToken["Filter"]> | OakOperation<"remove", OauthToken["RemoveOperationData"], OauthToken["Filter"]>)[];
|
|
oauthUser$user?: (OakOperation<"create", Omit<OauthUser["CreateOperationData"], "user"> | Omit<OauthUser["CreateOperationData"], "user">[]> | OakOperation<BaseOauthUser.OpUpdateAction, Omit<OauthUser["UpdateOperationData"], "user">, OauthUser["Filter"]> | OakOperation<"remove", OauthUser["RemoveOperationData"], OauthUser["Filter"]>)[];
|
|
oauthUserAuthorization$user?: (OakOperation<"create", Omit<OauthUserAuthorization["CreateOperationData"], "user"> | Omit<OauthUserAuthorization["CreateOperationData"], "user">[]> | OakOperation<BaseOauthUserAuthorization.OpUpdateAction, Omit<OauthUserAuthorization["UpdateOperationData"], "user">, OauthUserAuthorization["Filter"]> | OakOperation<"remove", OauthUserAuthorization["RemoveOperationData"], OauthUserAuthorization["Filter"]>)[];
|
|
parasite$user?: (OakOperation<"create", Omit<Parasite["CreateOperationData"], "user"> | Omit<Parasite["CreateOperationData"], "user">[]> | OakOperation<BaseParasite.OpUpdateAction, Omit<Parasite["UpdateOperationData"], "user">, Parasite["Filter"]> | OakOperation<"remove", Parasite["RemoveOperationData"], Parasite["Filter"]>)[];
|
|
readRemark$user?: (OakOperation<"create", Omit<ReadRemark["CreateOperationData"], "user"> | Omit<ReadRemark["CreateOperationData"], "user">[]> | OakOperation<BaseReadRemark.OpUpdateAction, Omit<ReadRemark["UpdateOperationData"], "user">, ReadRemark["Filter"]> | OakOperation<"remove", ReadRemark["RemoveOperationData"], ReadRemark["Filter"]>)[];
|
|
session$user?: (OakOperation<"create", Omit<Session["CreateOperationData"], "user"> | Omit<Session["CreateOperationData"], "user">[]> | OakOperation<BaseSession.OpUpdateAction, Omit<Session["UpdateOperationData"], "user">, Session["Filter"]> | OakOperation<"remove", Session["RemoveOperationData"], Session["Filter"]>)[];
|
|
sessionMessage$user?: (OakOperation<"create", Omit<SessionMessage["CreateOperationData"], "user"> | Omit<SessionMessage["CreateOperationData"], "user">[]> | OakOperation<BaseSessionMessage.OpUpdateAction, Omit<SessionMessage["UpdateOperationData"], "user">, SessionMessage["Filter"]> | OakOperation<"remove", SessionMessage["RemoveOperationData"], SessionMessage["Filter"]>)[];
|
|
token$user?: (OakOperation<"create", Omit<Token["CreateOperationData"], "user"> | Omit<Token["CreateOperationData"], "user">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "user">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
token$player?: (OakOperation<"create", Omit<Token["CreateOperationData"], "player"> | Omit<Token["CreateOperationData"], "player">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "player">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
userEntityGrant$granter?: (OakOperation<"create", Omit<UserEntityGrant["CreateOperationData"], "granter"> | Omit<UserEntityGrant["CreateOperationData"], "granter">[]> | OakOperation<BaseUserEntityGrant.OpUpdateAction, Omit<UserEntityGrant["UpdateOperationData"], "granter">, UserEntityGrant["Filter"]> | OakOperation<"remove", UserEntityGrant["RemoveOperationData"], UserEntityGrant["Filter"]>)[];
|
|
userSystem$user?: (OakOperation<"create", Omit<UserSystem["CreateOperationData"], "user"> | Omit<UserSystem["CreateOperationData"], "user">[]> | OakOperation<BaseUserSystem.OpUpdateAction, Omit<UserSystem["UpdateOperationData"], "user">, UserSystem["Filter"]> | OakOperation<"remove", UserSystem["RemoveOperationData"], UserSystem["Filter"]>)[];
|
|
wechatLogin$user?: (OakOperation<"create", Omit<WechatLogin["CreateOperationData"], "user"> | Omit<WechatLogin["CreateOperationData"], "user">[]> | OakOperation<BaseWechatLogin.OpUpdateAction, Omit<WechatLogin["UpdateOperationData"], "user">, WechatLogin["Filter"]> | OakOperation<"remove", WechatLogin["RemoveOperationData"], WechatLogin["Filter"]>)[];
|
|
wechatUser$user?: (OakOperation<"create", Omit<WechatUser["CreateOperationData"], "user"> | Omit<WechatUser["CreateOperationData"], "user">[]> | OakOperation<BaseWechatUser.OpUpdateAction, Omit<WechatUser["UpdateOperationData"], "user">, WechatUser["Filter"]> | OakOperation<"remove", WechatUser["RemoveOperationData"], WechatUser["Filter"]>)[];
|
|
deposit$creator?: (OakOperation<"create", Omit<Deposit["CreateOperationData"], "creator"> | Omit<Deposit["CreateOperationData"], "creator">[]> | OakOperation<BaseDeposit.OpUpdateAction, Omit<Deposit["UpdateOperationData"], "creator">, Deposit["Filter"]> | OakOperation<"remove", Deposit["RemoveOperationData"], Deposit["Filter"]>)[];
|
|
order$creator?: (OakOperation<"create", Omit<Order["CreateOperationData"], "creator"> | Omit<Order["CreateOperationData"], "creator">[]> | OakOperation<BaseOrder.OpUpdateAction, Omit<Order["UpdateOperationData"], "creator">, Order["Filter"]> | OakOperation<"remove", Order["RemoveOperationData"], Order["Filter"]>)[];
|
|
pay$creator?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "creator"> | Omit<Pay["CreateOperationData"], "creator">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "creator">, Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>)[];
|
|
refund$creator?: (OakOperation<"create", Omit<Refund["CreateOperationData"], "creator"> | Omit<Refund["CreateOperationData"], "creator">[]> | OakOperation<BaseRefund.OpUpdateAction, Omit<Refund["UpdateOperationData"], "creator">, Refund["Filter"]> | OakOperation<"remove", Refund["RemoveOperationData"], Refund["Filter"]>)[];
|
|
sysAccountMove$operator?: OakOperation<"create", Omit<SysAccountMove["CreateOperationData"], "operator"> | Omit<SysAccountMove["CreateOperationData"], "operator">[]>[];
|
|
withdraw$creator?: (OakOperation<"create", Omit<Withdraw["CreateOperationData"], "creator"> | Omit<Withdraw["CreateOperationData"], "creator">[]> | OakOperation<BaseWithdraw.OpUpdateAction, Omit<Withdraw["UpdateOperationData"], "creator">, Withdraw["Filter"]> | OakOperation<"remove", Withdraw["RemoveOperationData"], Withdraw["Filter"]>)[];
|
|
withdrawTransfer$operator?: (OakOperation<"create", Omit<WithdrawTransfer["CreateOperationData"], "operator"> | Omit<WithdrawTransfer["CreateOperationData"], "operator">[]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, Omit<WithdrawTransfer["UpdateOperationData"], "operator">, WithdrawTransfer["Filter"]> | OakOperation<"remove", WithdrawTransfer["RemoveOperationData"], WithdrawTransfer["Filter"]>)[];
|
|
withdrawTransfer$creator?: (OakOperation<"create", Omit<WithdrawTransfer["CreateOperationData"], "creator"> | Omit<WithdrawTransfer["CreateOperationData"], "creator">[]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, Omit<WithdrawTransfer["UpdateOperationData"], "creator">, WithdrawTransfer["Filter"]> | OakOperation<"remove", WithdrawTransfer["RemoveOperationData"], WithdrawTransfer["Filter"]>)[];
|
|
extraFile$entity?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "user"> | Omit<ExtraFile["CreateOperationData"], "user">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "user">, ExtraFile["Filter"]> | OakOperation<"remove", ExtraFile["RemoveOperationData"], ExtraFile["Filter"]>)[];
|
|
wechatQrCode$entity?: (OakOperation<"create", Omit<WechatQrCode["CreateOperationData"], "user"> | Omit<WechatQrCode["CreateOperationData"], "user">[]> | OakOperation<BaseWechatQrCode.OpUpdateAction, Omit<WechatQrCode["UpdateOperationData"], "user">, WechatQrCode["Filter"]> | OakOperation<"remove", WechatQrCode["RemoveOperationData"], WechatQrCode["Filter"]>)[];
|
|
address$entity?: (OakOperation<"create", Omit<Address["CreateOperationData"], "user"> | Omit<Address["CreateOperationData"], "user">[]> | OakOperation<BaseAddress.OpUpdateAction, Omit<Address["UpdateOperationData"], "user">, Address["Filter"]> | OakOperation<"remove", Address["RemoveOperationData"], Address["Filter"]>)[];
|
|
account$entity?: (OakOperation<"create", Omit<Account["CreateOperationData"], "user"> | Omit<Account["CreateOperationData"], "user">[]> | OakOperation<BaseAccount.OpUpdateAction, Omit<Account["UpdateOperationData"], "user">, Account["Filter"]> | OakOperation<"remove", Account["RemoveOperationData"], Account["Filter"]>)[];
|
|
withdrawAccount$entity?: (OakOperation<"create", Omit<WithdrawAccount["CreateOperationData"], "user"> | Omit<WithdrawAccount["CreateOperationData"], "user">[]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, Omit<WithdrawAccount["UpdateOperationData"], "user">, WithdrawAccount["Filter"]> | OakOperation<"remove", WithdrawAccount["RemoveOperationData"], WithdrawAccount["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 & {
|
|
granter: User["Schema"];
|
|
userEntityClaim$ueg?: Array<Omit<UserEntityClaim["Schema"], "ueg">>;
|
|
wechatQrCode$entity?: Array<Omit<WechatQrCode["Schema"], "entity">>;
|
|
userEntityClaim$ueg$$aggr?: AggregationResult<Omit<UserEntityClaim["Schema"], "ueg">>;
|
|
wechatQrCode$entity$$aggr?: AggregationResult<Omit<WechatQrCode["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseUserEntityGrant.OpProjection & {
|
|
granter?: User["Projection"];
|
|
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";
|
|
};
|
|
wechatQrCode$entity?: OakSelection<"select", Omit<WechatQrCode["Projection"], "userEntityGrant">, Omit<WechatQrCode["Filter"], "userEntityGrant">, WechatQrCode["Sorter"]> & {
|
|
$entity: "wechatQrCode";
|
|
};
|
|
wechatQrCode$entity$$aggr?: DeduceAggregation<Omit<WechatQrCode["Projection"], "userEntityGrant">, Omit<WechatQrCode["Filter"], "userEntityGrant">, WechatQrCode["Sorter"]> & {
|
|
$entity: "wechatQrCode";
|
|
};
|
|
};
|
|
FilterUnit: BaseUserEntityGrant.OpFilter & {
|
|
granter: MakeFilter<User["FilterUnit"]>;
|
|
userEntityClaim$ueg: MakeFilter<Omit<UserEntityClaim["FilterUnit"], "ueg">> & SubQueryPredicateMetadata;
|
|
wechatQrCode$entity: MakeFilter<Omit<WechatQrCode["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<UserEntityGrant["FilterUnit"]>;
|
|
SortAttr: Partial<BaseUserEntityGrant.OpSortAttr | {
|
|
granter: User["SortAttr"];
|
|
}>;
|
|
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 & {
|
|
granter?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
userEntityClaim$ueg?: (OakOperation<"create", Omit<UserEntityClaim["CreateOperationData"], "ueg"> | Omit<UserEntityClaim["CreateOperationData"], "ueg">[]> | OakOperation<BaseUserEntityClaim.OpUpdateAction, Omit<UserEntityClaim["UpdateOperationData"], "ueg">, UserEntityClaim["Filter"]>)[];
|
|
wechatQrCode$entity?: (OakOperation<"create", Omit<WechatQrCode["CreateOperationData"], "userEntityGrant"> | Omit<WechatQrCode["CreateOperationData"], "userEntityGrant">[]> | OakOperation<BaseWechatQrCode.OpUpdateAction, Omit<WechatQrCode["UpdateOperationData"], "userEntityGrant">, WechatQrCode["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", UserEntityGrant["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<UserEntityGrant["CreateOperationData"]>>;
|
|
Create: UserEntityGrant["CreateSingle"] | UserEntityGrant["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseUserEntityGrant.OpSchema & {
|
|
granter?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
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"]>)[];
|
|
wechatQrCode$entity?: (OakOperation<"create", Omit<WechatQrCode["CreateOperationData"], "userEntityGrant"> | Omit<WechatQrCode["CreateOperationData"], "userEntityGrant">[]> | OakOperation<BaseWechatQrCode.OpUpdateAction, Omit<WechatQrCode["UpdateOperationData"], "userEntityGrant">, WechatQrCode["Filter"]> | OakOperation<"remove", WechatQrCode["RemoveOperationData"], WechatQrCode["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"];
|
|
platform?: Platform["Schema"];
|
|
session?: Session["Schema"];
|
|
toDo?: ToDo["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"];
|
|
platform?: Platform["Projection"];
|
|
session?: Session["Projection"];
|
|
toDo?: ToDo["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"]>;
|
|
platform: MakeFilter<Platform["FilterUnit"]>;
|
|
session: MakeFilter<Session["FilterUnit"]>;
|
|
toDo: MakeFilter<ToDo["FilterUnit"]>;
|
|
userEntityClaim$userRelation: MakeFilter<Omit<UserEntityClaim["FilterUnit"], "userRelation">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<UserRelation["FilterUnit"]>;
|
|
SortAttr: Partial<BaseUserRelation.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
relation: Relation["SortAttr"];
|
|
platform: Platform["SortAttr"];
|
|
session: Session["SortAttr"];
|
|
toDo: ToDo["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"]>;
|
|
platform?: OakOperation<"create", Platform["CreateOperationData"]> | OakOperation<BasePlatform.OpUpdateAction, Platform["UpdateOperationData"], Platform["Filter"]>;
|
|
session?: OakOperation<"create", Session["CreateOperationData"]> | OakOperation<BaseSession.OpUpdateAction, Session["UpdateOperationData"], Session["Filter"]>;
|
|
toDo?: OakOperation<"create", ToDo["CreateOperationData"]> | OakOperation<BaseToDo.OpUpdateAction, ToDo["UpdateOperationData"], ToDo["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"]>;
|
|
platform?: OakOperation<"create", Platform["CreateOperationData"]> | OakOperation<BasePlatform.OpUpdateAction, Platform["UpdateOperationData"], Platform["Filter"]> | OakOperation<"remove", Platform["RemoveOperationData"], Platform["Filter"]>;
|
|
session?: OakOperation<"create", Session["CreateOperationData"]> | OakOperation<BaseSession.OpUpdateAction, Session["UpdateOperationData"], Session["Filter"]> | OakOperation<"remove", Session["RemoveOperationData"], Session["Filter"]>;
|
|
toDo?: OakOperation<"create", ToDo["CreateOperationData"]> | OakOperation<BaseToDo.OpUpdateAction, ToDo["UpdateOperationData"], ToDo["Filter"]> | OakOperation<"remove", ToDo["RemoveOperationData"], ToDo["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 Address = {
|
|
OpSchema: BaseAddress.OpSchema;
|
|
Action: BaseAddress.OpAction;
|
|
Schema: BaseAddress.OpSchema & {
|
|
area: Area["Schema"];
|
|
user?: User["Schema"];
|
|
order$address?: Array<Omit<Order["Schema"], "address">>;
|
|
ship$to?: Array<Omit<Ship["Schema"], "to">>;
|
|
ship$from?: Array<Omit<Ship["Schema"], "from">>;
|
|
order$address$$aggr?: AggregationResult<Omit<Order["Schema"], "address">>;
|
|
ship$to$$aggr?: AggregationResult<Omit<Ship["Schema"], "to">>;
|
|
ship$from$$aggr?: AggregationResult<Omit<Ship["Schema"], "from">>;
|
|
};
|
|
Projection: BaseAddress.OpProjection & {
|
|
area?: Area["Projection"];
|
|
user?: User["Projection"];
|
|
order$address?: OakSelection<"select", Omit<Order["Projection"], "address">, Omit<Order["Filter"], "address">, Order["Sorter"]> & {
|
|
$entity: "order";
|
|
};
|
|
order$address$$aggr?: DeduceAggregation<Omit<Order["Projection"], "address">, Omit<Order["Filter"], "address">, Order["Sorter"]> & {
|
|
$entity: "order";
|
|
};
|
|
ship$to?: OakSelection<"select", Omit<Ship["Projection"], "address">, Omit<Ship["Filter"], "address">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
ship$to$$aggr?: DeduceAggregation<Omit<Ship["Projection"], "address">, Omit<Ship["Filter"], "address">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
ship$from?: OakSelection<"select", Omit<Ship["Projection"], "address">, Omit<Ship["Filter"], "address">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
ship$from$$aggr?: DeduceAggregation<Omit<Ship["Projection"], "address">, Omit<Ship["Filter"], "address">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
};
|
|
FilterUnit: BaseAddress.OpFilter & {
|
|
area: MakeFilter<Area["FilterUnit"]>;
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
order$address: MakeFilter<Omit<Order["FilterUnit"], "address">> & SubQueryPredicateMetadata;
|
|
ship$to: MakeFilter<Omit<Ship["FilterUnit"], "to">> & SubQueryPredicateMetadata;
|
|
ship$from: MakeFilter<Omit<Ship["FilterUnit"], "from">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Address["FilterUnit"]>;
|
|
SortAttr: Partial<BaseAddress.OpSortAttr | {
|
|
area: Area["SortAttr"];
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Address["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Address["SortNode"][];
|
|
Selection: OakSelection<"select", Address["Projection"], Address["Filter"], Address["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Address["Projection"], Address["Filter"], Address["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseAddress.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
order$address?: (OakOperation<"create", Omit<Order["CreateOperationData"], "address"> | Omit<Order["CreateOperationData"], "address">[]> | OakOperation<BaseOrder.OpUpdateAction, Omit<Order["UpdateOperationData"], "address">, Order["Filter"]>)[];
|
|
ship$to?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "to"> | Omit<Ship["CreateOperationData"], "to">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "to">, Ship["Filter"]>)[];
|
|
ship$from?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "from"> | Omit<Ship["CreateOperationData"], "from">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "from">, Ship["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Address["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Address["CreateOperationData"]>>;
|
|
Create: Address["CreateSingle"] | Address["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseAddress.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
order$address?: (OakOperation<"create", Omit<Order["CreateOperationData"], "address"> | Omit<Order["CreateOperationData"], "address">[]> | OakOperation<BaseOrder.OpUpdateAction, Omit<Order["UpdateOperationData"], "address">, Order["Filter"]> | OakOperation<"remove", Order["RemoveOperationData"], Order["Filter"]>)[];
|
|
ship$to?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "to"> | Omit<Ship["CreateOperationData"], "to">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "to">, Ship["Filter"]> | OakOperation<"remove", Ship["RemoveOperationData"], Ship["Filter"]>)[];
|
|
ship$from?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "from"> | Omit<Ship["CreateOperationData"], "from">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "from">, Ship["Filter"]> | OakOperation<"remove", Ship["RemoveOperationData"], Ship["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseAddress.OpUpdateAction, Address["UpdateOperationData"], Address["Filter"], Address["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Address["RemoveOperationData"], Address["Filter"], Address["Sorter"]>;
|
|
Operation: Address["Create"] | Address["Update"] | Address["Remove"];
|
|
};
|
|
export type Application = {
|
|
OpSchema: BaseApplication.OpSchema;
|
|
Action: BaseApplication.OpAction;
|
|
Schema: BaseApplication.OpSchema & {
|
|
system: System["Schema"];
|
|
domain?: Domain["Schema"];
|
|
applicationPassport$application?: Array<Omit<ApplicationPassport["Schema"], "application">>;
|
|
captcha$application?: Array<Omit<Captcha["Schema"], "application">>;
|
|
extraFile$application?: Array<Omit<ExtraFile["Schema"], "application">>;
|
|
notification$application?: Array<Omit<Notification["Schema"], "application">>;
|
|
oauthAuthorizationCode$application?: Array<Omit<OauthAuthorizationCode["Schema"], "application">>;
|
|
oauthUser$application?: Array<Omit<OauthUser["Schema"], "application">>;
|
|
sessionMessage$application?: Array<Omit<SessionMessage["Schema"], "application">>;
|
|
token$application?: Array<Omit<Token["Schema"], "application">>;
|
|
wechatMenu$application?: Array<Omit<WechatMenu["Schema"], "application">>;
|
|
wechatPublicAutoReply$application?: Array<Omit<WechatPublicAutoReply["Schema"], "application">>;
|
|
wechatPublicTag$application?: Array<Omit<WechatPublicTag["Schema"], "application">>;
|
|
wechatQrCode$application?: Array<Omit<WechatQrCode["Schema"], "application">>;
|
|
wechatTemplate$application?: Array<Omit<WechatTemplate["Schema"], "application">>;
|
|
wechatUser$application?: Array<Omit<WechatUser["Schema"], "application">>;
|
|
abstractPayProduct$application?: Array<Omit<AbstractPayProduct["Schema"], "application">>;
|
|
apProduct$application?: Array<Omit<ApProduct["Schema"], "application">>;
|
|
pay$application?: Array<Omit<Pay["Schema"], "application">>;
|
|
wechatMpShip$application?: Array<Omit<WechatMpShip["Schema"], "application">>;
|
|
wpProduct$application?: Array<Omit<WpProduct["Schema"], "application">>;
|
|
session$entity?: Array<Omit<Session["Schema"], "entity">>;
|
|
applicationPassport$application$$aggr?: AggregationResult<Omit<ApplicationPassport["Schema"], "application">>;
|
|
captcha$application$$aggr?: AggregationResult<Omit<Captcha["Schema"], "application">>;
|
|
extraFile$application$$aggr?: AggregationResult<Omit<ExtraFile["Schema"], "application">>;
|
|
notification$application$$aggr?: AggregationResult<Omit<Notification["Schema"], "application">>;
|
|
oauthAuthorizationCode$application$$aggr?: AggregationResult<Omit<OauthAuthorizationCode["Schema"], "application">>;
|
|
oauthUser$application$$aggr?: AggregationResult<Omit<OauthUser["Schema"], "application">>;
|
|
sessionMessage$application$$aggr?: AggregationResult<Omit<SessionMessage["Schema"], "application">>;
|
|
token$application$$aggr?: AggregationResult<Omit<Token["Schema"], "application">>;
|
|
wechatMenu$application$$aggr?: AggregationResult<Omit<WechatMenu["Schema"], "application">>;
|
|
wechatPublicAutoReply$application$$aggr?: AggregationResult<Omit<WechatPublicAutoReply["Schema"], "application">>;
|
|
wechatPublicTag$application$$aggr?: AggregationResult<Omit<WechatPublicTag["Schema"], "application">>;
|
|
wechatQrCode$application$$aggr?: AggregationResult<Omit<WechatQrCode["Schema"], "application">>;
|
|
wechatTemplate$application$$aggr?: AggregationResult<Omit<WechatTemplate["Schema"], "application">>;
|
|
wechatUser$application$$aggr?: AggregationResult<Omit<WechatUser["Schema"], "application">>;
|
|
abstractPayProduct$application$$aggr?: AggregationResult<Omit<AbstractPayProduct["Schema"], "application">>;
|
|
apProduct$application$$aggr?: AggregationResult<Omit<ApProduct["Schema"], "application">>;
|
|
pay$application$$aggr?: AggregationResult<Omit<Pay["Schema"], "application">>;
|
|
wechatMpShip$application$$aggr?: AggregationResult<Omit<WechatMpShip["Schema"], "application">>;
|
|
wpProduct$application$$aggr?: AggregationResult<Omit<WpProduct["Schema"], "application">>;
|
|
session$entity$$aggr?: AggregationResult<Omit<Session["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseApplication.OpProjection & {
|
|
system?: System["Projection"];
|
|
domain?: Domain["Projection"];
|
|
applicationPassport$application?: OakSelection<"select", Omit<ApplicationPassport["Projection"], "application">, Omit<ApplicationPassport["Filter"], "application">, ApplicationPassport["Sorter"]> & {
|
|
$entity: "applicationPassport";
|
|
};
|
|
applicationPassport$application$$aggr?: DeduceAggregation<Omit<ApplicationPassport["Projection"], "application">, Omit<ApplicationPassport["Filter"], "application">, ApplicationPassport["Sorter"]> & {
|
|
$entity: "applicationPassport";
|
|
};
|
|
captcha$application?: OakSelection<"select", Omit<Captcha["Projection"], "application">, Omit<Captcha["Filter"], "application">, Captcha["Sorter"]> & {
|
|
$entity: "captcha";
|
|
};
|
|
captcha$application$$aggr?: DeduceAggregation<Omit<Captcha["Projection"], "application">, Omit<Captcha["Filter"], "application">, Captcha["Sorter"]> & {
|
|
$entity: "captcha";
|
|
};
|
|
extraFile$application?: OakSelection<"select", Omit<ExtraFile["Projection"], "application">, Omit<ExtraFile["Filter"], "application">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
extraFile$application$$aggr?: DeduceAggregation<Omit<ExtraFile["Projection"], "application">, Omit<ExtraFile["Filter"], "application">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
notification$application?: OakSelection<"select", Omit<Notification["Projection"], "application">, Omit<Notification["Filter"], "application">, Notification["Sorter"]> & {
|
|
$entity: "notification";
|
|
};
|
|
notification$application$$aggr?: DeduceAggregation<Omit<Notification["Projection"], "application">, Omit<Notification["Filter"], "application">, Notification["Sorter"]> & {
|
|
$entity: "notification";
|
|
};
|
|
oauthAuthorizationCode$application?: OakSelection<"select", Omit<OauthAuthorizationCode["Projection"], "application">, Omit<OauthAuthorizationCode["Filter"], "application">, OauthAuthorizationCode["Sorter"]> & {
|
|
$entity: "oauthAuthorizationCode";
|
|
};
|
|
oauthAuthorizationCode$application$$aggr?: DeduceAggregation<Omit<OauthAuthorizationCode["Projection"], "application">, Omit<OauthAuthorizationCode["Filter"], "application">, OauthAuthorizationCode["Sorter"]> & {
|
|
$entity: "oauthAuthorizationCode";
|
|
};
|
|
oauthUser$application?: OakSelection<"select", Omit<OauthUser["Projection"], "application">, Omit<OauthUser["Filter"], "application">, OauthUser["Sorter"]> & {
|
|
$entity: "oauthUser";
|
|
};
|
|
oauthUser$application$$aggr?: DeduceAggregation<Omit<OauthUser["Projection"], "application">, Omit<OauthUser["Filter"], "application">, OauthUser["Sorter"]> & {
|
|
$entity: "oauthUser";
|
|
};
|
|
sessionMessage$application?: OakSelection<"select", Omit<SessionMessage["Projection"], "application">, Omit<SessionMessage["Filter"], "application">, SessionMessage["Sorter"]> & {
|
|
$entity: "sessionMessage";
|
|
};
|
|
sessionMessage$application$$aggr?: DeduceAggregation<Omit<SessionMessage["Projection"], "application">, Omit<SessionMessage["Filter"], "application">, SessionMessage["Sorter"]> & {
|
|
$entity: "sessionMessage";
|
|
};
|
|
token$application?: OakSelection<"select", Omit<Token["Projection"], "application">, Omit<Token["Filter"], "application">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$application$$aggr?: DeduceAggregation<Omit<Token["Projection"], "application">, Omit<Token["Filter"], "application">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
wechatMenu$application?: OakSelection<"select", Omit<WechatMenu["Projection"], "application">, Omit<WechatMenu["Filter"], "application">, WechatMenu["Sorter"]> & {
|
|
$entity: "wechatMenu";
|
|
};
|
|
wechatMenu$application$$aggr?: DeduceAggregation<Omit<WechatMenu["Projection"], "application">, Omit<WechatMenu["Filter"], "application">, WechatMenu["Sorter"]> & {
|
|
$entity: "wechatMenu";
|
|
};
|
|
wechatPublicAutoReply$application?: OakSelection<"select", Omit<WechatPublicAutoReply["Projection"], "application">, Omit<WechatPublicAutoReply["Filter"], "application">, WechatPublicAutoReply["Sorter"]> & {
|
|
$entity: "wechatPublicAutoReply";
|
|
};
|
|
wechatPublicAutoReply$application$$aggr?: DeduceAggregation<Omit<WechatPublicAutoReply["Projection"], "application">, Omit<WechatPublicAutoReply["Filter"], "application">, WechatPublicAutoReply["Sorter"]> & {
|
|
$entity: "wechatPublicAutoReply";
|
|
};
|
|
wechatPublicTag$application?: OakSelection<"select", Omit<WechatPublicTag["Projection"], "application">, Omit<WechatPublicTag["Filter"], "application">, WechatPublicTag["Sorter"]> & {
|
|
$entity: "wechatPublicTag";
|
|
};
|
|
wechatPublicTag$application$$aggr?: DeduceAggregation<Omit<WechatPublicTag["Projection"], "application">, Omit<WechatPublicTag["Filter"], "application">, WechatPublicTag["Sorter"]> & {
|
|
$entity: "wechatPublicTag";
|
|
};
|
|
wechatQrCode$application?: OakSelection<"select", Omit<WechatQrCode["Projection"], "application">, Omit<WechatQrCode["Filter"], "application">, WechatQrCode["Sorter"]> & {
|
|
$entity: "wechatQrCode";
|
|
};
|
|
wechatQrCode$application$$aggr?: DeduceAggregation<Omit<WechatQrCode["Projection"], "application">, Omit<WechatQrCode["Filter"], "application">, WechatQrCode["Sorter"]> & {
|
|
$entity: "wechatQrCode";
|
|
};
|
|
wechatTemplate$application?: OakSelection<"select", Omit<WechatTemplate["Projection"], "application">, Omit<WechatTemplate["Filter"], "application">, WechatTemplate["Sorter"]> & {
|
|
$entity: "wechatTemplate";
|
|
};
|
|
wechatTemplate$application$$aggr?: DeduceAggregation<Omit<WechatTemplate["Projection"], "application">, Omit<WechatTemplate["Filter"], "application">, WechatTemplate["Sorter"]> & {
|
|
$entity: "wechatTemplate";
|
|
};
|
|
wechatUser$application?: OakSelection<"select", Omit<WechatUser["Projection"], "application">, Omit<WechatUser["Filter"], "application">, WechatUser["Sorter"]> & {
|
|
$entity: "wechatUser";
|
|
};
|
|
wechatUser$application$$aggr?: DeduceAggregation<Omit<WechatUser["Projection"], "application">, Omit<WechatUser["Filter"], "application">, WechatUser["Sorter"]> & {
|
|
$entity: "wechatUser";
|
|
};
|
|
abstractPayProduct$application?: OakSelection<"select", Omit<AbstractPayProduct["Projection"], "application">, Omit<AbstractPayProduct["Filter"], "application">, AbstractPayProduct["Sorter"]> & {
|
|
$entity: "abstractPayProduct";
|
|
};
|
|
abstractPayProduct$application$$aggr?: DeduceAggregation<Omit<AbstractPayProduct["Projection"], "application">, Omit<AbstractPayProduct["Filter"], "application">, AbstractPayProduct["Sorter"]> & {
|
|
$entity: "abstractPayProduct";
|
|
};
|
|
apProduct$application?: OakSelection<"select", Omit<ApProduct["Projection"], "application">, Omit<ApProduct["Filter"], "application">, ApProduct["Sorter"]> & {
|
|
$entity: "apProduct";
|
|
};
|
|
apProduct$application$$aggr?: DeduceAggregation<Omit<ApProduct["Projection"], "application">, Omit<ApProduct["Filter"], "application">, ApProduct["Sorter"]> & {
|
|
$entity: "apProduct";
|
|
};
|
|
pay$application?: OakSelection<"select", Omit<Pay["Projection"], "application">, Omit<Pay["Filter"], "application">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
pay$application$$aggr?: DeduceAggregation<Omit<Pay["Projection"], "application">, Omit<Pay["Filter"], "application">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
wechatMpShip$application?: OakSelection<"select", Omit<WechatMpShip["Projection"], "application">, Omit<WechatMpShip["Filter"], "application">, WechatMpShip["Sorter"]> & {
|
|
$entity: "wechatMpShip";
|
|
};
|
|
wechatMpShip$application$$aggr?: DeduceAggregation<Omit<WechatMpShip["Projection"], "application">, Omit<WechatMpShip["Filter"], "application">, WechatMpShip["Sorter"]> & {
|
|
$entity: "wechatMpShip";
|
|
};
|
|
wpProduct$application?: OakSelection<"select", Omit<WpProduct["Projection"], "application">, Omit<WpProduct["Filter"], "application">, WpProduct["Sorter"]> & {
|
|
$entity: "wpProduct";
|
|
};
|
|
wpProduct$application$$aggr?: DeduceAggregation<Omit<WpProduct["Projection"], "application">, Omit<WpProduct["Filter"], "application">, WpProduct["Sorter"]> & {
|
|
$entity: "wpProduct";
|
|
};
|
|
session$entity?: OakSelection<"select", Omit<Session["Projection"], "application">, Omit<Session["Filter"], "application">, Session["Sorter"]> & {
|
|
$entity: "session";
|
|
};
|
|
session$entity$$aggr?: DeduceAggregation<Omit<Session["Projection"], "application">, Omit<Session["Filter"], "application">, Session["Sorter"]> & {
|
|
$entity: "session";
|
|
};
|
|
};
|
|
FilterUnit: BaseApplication.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
domain: MakeFilter<Domain["FilterUnit"]>;
|
|
applicationPassport$application: MakeFilter<Omit<ApplicationPassport["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
captcha$application: MakeFilter<Omit<Captcha["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
extraFile$application: MakeFilter<Omit<ExtraFile["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
notification$application: MakeFilter<Omit<Notification["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
oauthAuthorizationCode$application: MakeFilter<Omit<OauthAuthorizationCode["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
oauthUser$application: MakeFilter<Omit<OauthUser["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
sessionMessage$application: MakeFilter<Omit<SessionMessage["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
token$application: MakeFilter<Omit<Token["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
wechatMenu$application: MakeFilter<Omit<WechatMenu["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
wechatPublicAutoReply$application: MakeFilter<Omit<WechatPublicAutoReply["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
wechatPublicTag$application: MakeFilter<Omit<WechatPublicTag["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
wechatQrCode$application: MakeFilter<Omit<WechatQrCode["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
wechatTemplate$application: MakeFilter<Omit<WechatTemplate["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
wechatUser$application: MakeFilter<Omit<WechatUser["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
abstractPayProduct$application: MakeFilter<Omit<AbstractPayProduct["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
apProduct$application: MakeFilter<Omit<ApProduct["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
pay$application: MakeFilter<Omit<Pay["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
wechatMpShip$application: MakeFilter<Omit<WechatMpShip["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
wpProduct$application: MakeFilter<Omit<WpProduct["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
session$entity: MakeFilter<Omit<Session["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Application["FilterUnit"]>;
|
|
SortAttr: Partial<BaseApplication.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
domain: Domain["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Application["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Application["SortNode"][];
|
|
Selection: OakSelection<"select", Application["Projection"], Application["Filter"], Application["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Application["Projection"], Application["Filter"], Application["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseApplication.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
domain?: OakOperation<"create", Domain["CreateOperationData"]> | OakOperation<BaseDomain.OpUpdateAction, Domain["UpdateOperationData"], Domain["Filter"]>;
|
|
applicationPassport$application?: (OakOperation<"create", Omit<ApplicationPassport["CreateOperationData"], "application"> | Omit<ApplicationPassport["CreateOperationData"], "application">[]> | OakOperation<BaseApplicationPassport.OpUpdateAction, Omit<ApplicationPassport["UpdateOperationData"], "application">, ApplicationPassport["Filter"]>)[];
|
|
captcha$application?: (OakOperation<"create", Omit<Captcha["CreateOperationData"], "application"> | Omit<Captcha["CreateOperationData"], "application">[]> | OakOperation<BaseCaptcha.OpUpdateAction, Omit<Captcha["UpdateOperationData"], "application">, Captcha["Filter"]>)[];
|
|
extraFile$application?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "application"> | Omit<ExtraFile["CreateOperationData"], "application">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "application">, ExtraFile["Filter"]>)[];
|
|
notification$application?: (OakOperation<"create", Omit<Notification["CreateOperationData"], "application"> | Omit<Notification["CreateOperationData"], "application">[]> | OakOperation<BaseNotification.OpUpdateAction, Omit<Notification["UpdateOperationData"], "application">, Notification["Filter"]>)[];
|
|
oauthAuthorizationCode$application?: (OakOperation<"create", Omit<OauthAuthorizationCode["CreateOperationData"], "application"> | Omit<OauthAuthorizationCode["CreateOperationData"], "application">[]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, Omit<OauthAuthorizationCode["UpdateOperationData"], "application">, OauthAuthorizationCode["Filter"]>)[];
|
|
oauthUser$application?: (OakOperation<"create", Omit<OauthUser["CreateOperationData"], "application"> | Omit<OauthUser["CreateOperationData"], "application">[]> | OakOperation<BaseOauthUser.OpUpdateAction, Omit<OauthUser["UpdateOperationData"], "application">, OauthUser["Filter"]>)[];
|
|
sessionMessage$application?: (OakOperation<"create", Omit<SessionMessage["CreateOperationData"], "application"> | Omit<SessionMessage["CreateOperationData"], "application">[]> | OakOperation<BaseSessionMessage.OpUpdateAction, Omit<SessionMessage["UpdateOperationData"], "application">, SessionMessage["Filter"]>)[];
|
|
token$application?: (OakOperation<"create", Omit<Token["CreateOperationData"], "application"> | Omit<Token["CreateOperationData"], "application">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "application">, Token["Filter"]>)[];
|
|
wechatMenu$application?: (OakOperation<"create", Omit<WechatMenu["CreateOperationData"], "application"> | Omit<WechatMenu["CreateOperationData"], "application">[]> | OakOperation<BaseWechatMenu.OpUpdateAction, Omit<WechatMenu["UpdateOperationData"], "application">, WechatMenu["Filter"]>)[];
|
|
wechatPublicAutoReply$application?: (OakOperation<"create", Omit<WechatPublicAutoReply["CreateOperationData"], "application"> | Omit<WechatPublicAutoReply["CreateOperationData"], "application">[]> | OakOperation<BaseWechatPublicAutoReply.OpUpdateAction, Omit<WechatPublicAutoReply["UpdateOperationData"], "application">, WechatPublicAutoReply["Filter"]>)[];
|
|
wechatPublicTag$application?: (OakOperation<"create", Omit<WechatPublicTag["CreateOperationData"], "application"> | Omit<WechatPublicTag["CreateOperationData"], "application">[]> | OakOperation<BaseWechatPublicTag.OpUpdateAction, Omit<WechatPublicTag["UpdateOperationData"], "application">, WechatPublicTag["Filter"]>)[];
|
|
wechatQrCode$application?: (OakOperation<"create", Omit<WechatQrCode["CreateOperationData"], "application"> | Omit<WechatQrCode["CreateOperationData"], "application">[]> | OakOperation<BaseWechatQrCode.OpUpdateAction, Omit<WechatQrCode["UpdateOperationData"], "application">, WechatQrCode["Filter"]>)[];
|
|
wechatTemplate$application?: (OakOperation<"create", Omit<WechatTemplate["CreateOperationData"], "application"> | Omit<WechatTemplate["CreateOperationData"], "application">[]> | OakOperation<BaseWechatTemplate.OpUpdateAction, Omit<WechatTemplate["UpdateOperationData"], "application">, WechatTemplate["Filter"]>)[];
|
|
wechatUser$application?: (OakOperation<"create", Omit<WechatUser["CreateOperationData"], "application"> | Omit<WechatUser["CreateOperationData"], "application">[]> | OakOperation<BaseWechatUser.OpUpdateAction, Omit<WechatUser["UpdateOperationData"], "application">, WechatUser["Filter"]>)[];
|
|
abstractPayProduct$application?: (OakOperation<"create", Omit<AbstractPayProduct["CreateOperationData"], "application"> | Omit<AbstractPayProduct["CreateOperationData"], "application">[]> | OakOperation<BaseAbstractPayProduct.OpUpdateAction, Omit<AbstractPayProduct["UpdateOperationData"], "application">, AbstractPayProduct["Filter"]>)[];
|
|
apProduct$application?: (OakOperation<"create", Omit<ApProduct["CreateOperationData"], "application"> | Omit<ApProduct["CreateOperationData"], "application">[]> | OakOperation<BaseApProduct.OpUpdateAction, Omit<ApProduct["UpdateOperationData"], "application">, ApProduct["Filter"]>)[];
|
|
pay$application?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "application"> | Omit<Pay["CreateOperationData"], "application">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "application">, Pay["Filter"]>)[];
|
|
wechatMpShip$application?: (OakOperation<"create", Omit<WechatMpShip["CreateOperationData"], "application"> | Omit<WechatMpShip["CreateOperationData"], "application">[]> | OakOperation<BaseWechatMpShip.OpUpdateAction, Omit<WechatMpShip["UpdateOperationData"], "application">, WechatMpShip["Filter"]>)[];
|
|
wpProduct$application?: (OakOperation<"create", Omit<WpProduct["CreateOperationData"], "application"> | Omit<WpProduct["CreateOperationData"], "application">[]> | OakOperation<BaseWpProduct.OpUpdateAction, Omit<WpProduct["UpdateOperationData"], "application">, WpProduct["Filter"]>)[];
|
|
session$entity?: (OakOperation<"create", Omit<Session["CreateOperationData"], "application"> | Omit<Session["CreateOperationData"], "application">[]> | OakOperation<BaseSession.OpUpdateAction, Omit<Session["UpdateOperationData"], "application">, Session["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Application["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Application["CreateOperationData"]>>;
|
|
Create: Application["CreateSingle"] | Application["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseApplication.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
domain?: OakOperation<"create", Domain["CreateOperationData"]> | OakOperation<BaseDomain.OpUpdateAction, Domain["UpdateOperationData"], Domain["Filter"]> | OakOperation<"remove", Domain["RemoveOperationData"], Domain["Filter"]>;
|
|
applicationPassport$application?: (OakOperation<"create", Omit<ApplicationPassport["CreateOperationData"], "application"> | Omit<ApplicationPassport["CreateOperationData"], "application">[]> | OakOperation<BaseApplicationPassport.OpUpdateAction, Omit<ApplicationPassport["UpdateOperationData"], "application">, ApplicationPassport["Filter"]> | OakOperation<"remove", ApplicationPassport["RemoveOperationData"], ApplicationPassport["Filter"]>)[];
|
|
captcha$application?: (OakOperation<"create", Omit<Captcha["CreateOperationData"], "application"> | Omit<Captcha["CreateOperationData"], "application">[]> | OakOperation<BaseCaptcha.OpUpdateAction, Omit<Captcha["UpdateOperationData"], "application">, Captcha["Filter"]> | OakOperation<"remove", Captcha["RemoveOperationData"], Captcha["Filter"]>)[];
|
|
extraFile$application?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "application"> | Omit<ExtraFile["CreateOperationData"], "application">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "application">, ExtraFile["Filter"]> | OakOperation<"remove", ExtraFile["RemoveOperationData"], ExtraFile["Filter"]>)[];
|
|
notification$application?: (OakOperation<"create", Omit<Notification["CreateOperationData"], "application"> | Omit<Notification["CreateOperationData"], "application">[]> | OakOperation<BaseNotification.OpUpdateAction, Omit<Notification["UpdateOperationData"], "application">, Notification["Filter"]> | OakOperation<"remove", Notification["RemoveOperationData"], Notification["Filter"]>)[];
|
|
oauthAuthorizationCode$application?: (OakOperation<"create", Omit<OauthAuthorizationCode["CreateOperationData"], "application"> | Omit<OauthAuthorizationCode["CreateOperationData"], "application">[]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, Omit<OauthAuthorizationCode["UpdateOperationData"], "application">, OauthAuthorizationCode["Filter"]> | OakOperation<"remove", OauthAuthorizationCode["RemoveOperationData"], OauthAuthorizationCode["Filter"]>)[];
|
|
oauthUser$application?: (OakOperation<"create", Omit<OauthUser["CreateOperationData"], "application"> | Omit<OauthUser["CreateOperationData"], "application">[]> | OakOperation<BaseOauthUser.OpUpdateAction, Omit<OauthUser["UpdateOperationData"], "application">, OauthUser["Filter"]> | OakOperation<"remove", OauthUser["RemoveOperationData"], OauthUser["Filter"]>)[];
|
|
sessionMessage$application?: (OakOperation<"create", Omit<SessionMessage["CreateOperationData"], "application"> | Omit<SessionMessage["CreateOperationData"], "application">[]> | OakOperation<BaseSessionMessage.OpUpdateAction, Omit<SessionMessage["UpdateOperationData"], "application">, SessionMessage["Filter"]> | OakOperation<"remove", SessionMessage["RemoveOperationData"], SessionMessage["Filter"]>)[];
|
|
token$application?: (OakOperation<"create", Omit<Token["CreateOperationData"], "application"> | Omit<Token["CreateOperationData"], "application">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "application">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
wechatMenu$application?: (OakOperation<"create", Omit<WechatMenu["CreateOperationData"], "application"> | Omit<WechatMenu["CreateOperationData"], "application">[]> | OakOperation<BaseWechatMenu.OpUpdateAction, Omit<WechatMenu["UpdateOperationData"], "application">, WechatMenu["Filter"]> | OakOperation<"remove", WechatMenu["RemoveOperationData"], WechatMenu["Filter"]>)[];
|
|
wechatPublicAutoReply$application?: (OakOperation<"create", Omit<WechatPublicAutoReply["CreateOperationData"], "application"> | Omit<WechatPublicAutoReply["CreateOperationData"], "application">[]> | OakOperation<BaseWechatPublicAutoReply.OpUpdateAction, Omit<WechatPublicAutoReply["UpdateOperationData"], "application">, WechatPublicAutoReply["Filter"]> | OakOperation<"remove", WechatPublicAutoReply["RemoveOperationData"], WechatPublicAutoReply["Filter"]>)[];
|
|
wechatPublicTag$application?: (OakOperation<"create", Omit<WechatPublicTag["CreateOperationData"], "application"> | Omit<WechatPublicTag["CreateOperationData"], "application">[]> | OakOperation<BaseWechatPublicTag.OpUpdateAction, Omit<WechatPublicTag["UpdateOperationData"], "application">, WechatPublicTag["Filter"]> | OakOperation<"remove", WechatPublicTag["RemoveOperationData"], WechatPublicTag["Filter"]>)[];
|
|
wechatQrCode$application?: (OakOperation<"create", Omit<WechatQrCode["CreateOperationData"], "application"> | Omit<WechatQrCode["CreateOperationData"], "application">[]> | OakOperation<BaseWechatQrCode.OpUpdateAction, Omit<WechatQrCode["UpdateOperationData"], "application">, WechatQrCode["Filter"]> | OakOperation<"remove", WechatQrCode["RemoveOperationData"], WechatQrCode["Filter"]>)[];
|
|
wechatTemplate$application?: (OakOperation<"create", Omit<WechatTemplate["CreateOperationData"], "application"> | Omit<WechatTemplate["CreateOperationData"], "application">[]> | OakOperation<BaseWechatTemplate.OpUpdateAction, Omit<WechatTemplate["UpdateOperationData"], "application">, WechatTemplate["Filter"]> | OakOperation<"remove", WechatTemplate["RemoveOperationData"], WechatTemplate["Filter"]>)[];
|
|
wechatUser$application?: (OakOperation<"create", Omit<WechatUser["CreateOperationData"], "application"> | Omit<WechatUser["CreateOperationData"], "application">[]> | OakOperation<BaseWechatUser.OpUpdateAction, Omit<WechatUser["UpdateOperationData"], "application">, WechatUser["Filter"]> | OakOperation<"remove", WechatUser["RemoveOperationData"], WechatUser["Filter"]>)[];
|
|
abstractPayProduct$application?: (OakOperation<"create", Omit<AbstractPayProduct["CreateOperationData"], "application"> | Omit<AbstractPayProduct["CreateOperationData"], "application">[]> | OakOperation<BaseAbstractPayProduct.OpUpdateAction, Omit<AbstractPayProduct["UpdateOperationData"], "application">, AbstractPayProduct["Filter"]> | OakOperation<"remove", AbstractPayProduct["RemoveOperationData"], AbstractPayProduct["Filter"]>)[];
|
|
apProduct$application?: (OakOperation<"create", Omit<ApProduct["CreateOperationData"], "application"> | Omit<ApProduct["CreateOperationData"], "application">[]> | OakOperation<BaseApProduct.OpUpdateAction, Omit<ApProduct["UpdateOperationData"], "application">, ApProduct["Filter"]> | OakOperation<"remove", ApProduct["RemoveOperationData"], ApProduct["Filter"]>)[];
|
|
pay$application?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "application"> | Omit<Pay["CreateOperationData"], "application">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "application">, Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>)[];
|
|
wechatMpShip$application?: (OakOperation<"create", Omit<WechatMpShip["CreateOperationData"], "application"> | Omit<WechatMpShip["CreateOperationData"], "application">[]> | OakOperation<BaseWechatMpShip.OpUpdateAction, Omit<WechatMpShip["UpdateOperationData"], "application">, WechatMpShip["Filter"]> | OakOperation<"remove", WechatMpShip["RemoveOperationData"], WechatMpShip["Filter"]>)[];
|
|
wpProduct$application?: (OakOperation<"create", Omit<WpProduct["CreateOperationData"], "application"> | Omit<WpProduct["CreateOperationData"], "application">[]> | OakOperation<BaseWpProduct.OpUpdateAction, Omit<WpProduct["UpdateOperationData"], "application">, WpProduct["Filter"]> | OakOperation<"remove", WpProduct["RemoveOperationData"], WpProduct["Filter"]>)[];
|
|
session$entity?: (OakOperation<"create", Omit<Session["CreateOperationData"], "application"> | Omit<Session["CreateOperationData"], "application">[]> | OakOperation<BaseSession.OpUpdateAction, Omit<Session["UpdateOperationData"], "application">, Session["Filter"]> | OakOperation<"remove", Session["RemoveOperationData"], Session["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"], Application["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"], Application["Sorter"]>;
|
|
Operation: Application["Create"] | Application["Update"] | Application["Remove"];
|
|
};
|
|
export type ApplicationPassport = {
|
|
OpSchema: BaseApplicationPassport.OpSchema;
|
|
Action: BaseApplicationPassport.OpAction;
|
|
Schema: BaseApplicationPassport.OpSchema & {
|
|
application: Application["Schema"];
|
|
passport: Passport["Schema"];
|
|
};
|
|
Projection: BaseApplicationPassport.OpProjection & {
|
|
application?: Application["Projection"];
|
|
passport?: Passport["Projection"];
|
|
};
|
|
FilterUnit: BaseApplicationPassport.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
passport: MakeFilter<Passport["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<ApplicationPassport["FilterUnit"]>;
|
|
SortAttr: Partial<BaseApplicationPassport.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
passport: Passport["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ApplicationPassport["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ApplicationPassport["SortNode"][];
|
|
Selection: OakSelection<"select", ApplicationPassport["Projection"], ApplicationPassport["Filter"], ApplicationPassport["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ApplicationPassport["Projection"], ApplicationPassport["Filter"], ApplicationPassport["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseApplicationPassport.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
passport?: OakOperation<"create", Passport["CreateOperationData"]> | OakOperation<BasePassport.OpUpdateAction, Passport["UpdateOperationData"], Passport["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ApplicationPassport["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ApplicationPassport["CreateOperationData"]>>;
|
|
Create: ApplicationPassport["CreateSingle"] | ApplicationPassport["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseApplicationPassport.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
passport?: OakOperation<"create", Passport["CreateOperationData"]> | OakOperation<BasePassport.OpUpdateAction, Passport["UpdateOperationData"], Passport["Filter"]> | OakOperation<"remove", Passport["RemoveOperationData"], Passport["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseApplicationPassport.OpUpdateAction, ApplicationPassport["UpdateOperationData"], ApplicationPassport["Filter"], ApplicationPassport["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ApplicationPassport["RemoveOperationData"], ApplicationPassport["Filter"], ApplicationPassport["Sorter"]>;
|
|
Operation: ApplicationPassport["Create"] | ApplicationPassport["Update"] | ApplicationPassport["Remove"];
|
|
};
|
|
export type Area = {
|
|
OpSchema: BaseArea.OpSchema;
|
|
Action: BaseArea.OpAction;
|
|
Schema: BaseArea.OpSchema & {
|
|
parent?: Area["Schema"];
|
|
address$area?: Array<Omit<Address["Schema"], "area">>;
|
|
area$parent?: Array<Omit<Area["Schema"], "parent">>;
|
|
station$area?: Array<Omit<Station["Schema"], "area">>;
|
|
subway$area?: Array<Omit<Subway["Schema"], "area">>;
|
|
address$area$$aggr?: AggregationResult<Omit<Address["Schema"], "area">>;
|
|
area$parent$$aggr?: AggregationResult<Omit<Area["Schema"], "parent">>;
|
|
station$area$$aggr?: AggregationResult<Omit<Station["Schema"], "area">>;
|
|
subway$area$$aggr?: AggregationResult<Omit<Subway["Schema"], "area">>;
|
|
};
|
|
Projection: BaseArea.OpProjection & {
|
|
parent?: Area["Projection"];
|
|
address$area?: OakSelection<"select", Omit<Address["Projection"], "area">, Omit<Address["Filter"], "area">, Address["Sorter"]> & {
|
|
$entity: "address";
|
|
};
|
|
address$area$$aggr?: DeduceAggregation<Omit<Address["Projection"], "area">, Omit<Address["Filter"], "area">, Address["Sorter"]> & {
|
|
$entity: "address";
|
|
};
|
|
area$parent?: OakSelection<"select", Omit<Area["Projection"], "area">, Omit<Area["Filter"], "area">, Area["Sorter"]> & {
|
|
$entity: "area";
|
|
};
|
|
area$parent$$aggr?: DeduceAggregation<Omit<Area["Projection"], "area">, Omit<Area["Filter"], "area">, Area["Sorter"]> & {
|
|
$entity: "area";
|
|
};
|
|
station$area?: OakSelection<"select", Omit<Station["Projection"], "area">, Omit<Station["Filter"], "area">, Station["Sorter"]> & {
|
|
$entity: "station";
|
|
};
|
|
station$area$$aggr?: DeduceAggregation<Omit<Station["Projection"], "area">, Omit<Station["Filter"], "area">, Station["Sorter"]> & {
|
|
$entity: "station";
|
|
};
|
|
subway$area?: OakSelection<"select", Omit<Subway["Projection"], "area">, Omit<Subway["Filter"], "area">, Subway["Sorter"]> & {
|
|
$entity: "subway";
|
|
};
|
|
subway$area$$aggr?: DeduceAggregation<Omit<Subway["Projection"], "area">, Omit<Subway["Filter"], "area">, Subway["Sorter"]> & {
|
|
$entity: "subway";
|
|
};
|
|
};
|
|
FilterUnit: BaseArea.OpFilter & {
|
|
parent: MakeFilter<Area["FilterUnit"]>;
|
|
address$area: MakeFilter<Omit<Address["FilterUnit"], "area">> & SubQueryPredicateMetadata;
|
|
area$parent: MakeFilter<Omit<Area["FilterUnit"], "parent">> & SubQueryPredicateMetadata;
|
|
station$area: MakeFilter<Omit<Station["FilterUnit"], "area">> & SubQueryPredicateMetadata;
|
|
subway$area: MakeFilter<Omit<Subway["FilterUnit"], "area">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Area["FilterUnit"]>;
|
|
SortAttr: Partial<BaseArea.OpSortAttr | {
|
|
parent: Area["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Area["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Area["SortNode"][];
|
|
Selection: OakSelection<"select", Area["Projection"], Area["Filter"], Area["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Area["Projection"], Area["Filter"], Area["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseArea.OpSchema & {
|
|
address$area?: (OakOperation<"create", Omit<Address["CreateOperationData"], "area"> | Omit<Address["CreateOperationData"], "area">[]> | OakOperation<BaseAddress.OpUpdateAction, Omit<Address["UpdateOperationData"], "area">, Address["Filter"]>)[];
|
|
station$area?: (OakOperation<"create", Omit<Station["CreateOperationData"], "area"> | Omit<Station["CreateOperationData"], "area">[]> | OakOperation<BaseStation.OpUpdateAction, Omit<Station["UpdateOperationData"], "area">, Station["Filter"]>)[];
|
|
subway$area?: (OakOperation<"create", Omit<Subway["CreateOperationData"], "area"> | Omit<Subway["CreateOperationData"], "area">[]> | OakOperation<BaseSubway.OpUpdateAction, Omit<Subway["UpdateOperationData"], "area">, Subway["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Area["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Area["CreateOperationData"]>>;
|
|
Create: Area["CreateSingle"] | Area["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseArea.OpSchema & {
|
|
address$area?: (OakOperation<"create", Omit<Address["CreateOperationData"], "area"> | Omit<Address["CreateOperationData"], "area">[]> | OakOperation<BaseAddress.OpUpdateAction, Omit<Address["UpdateOperationData"], "area">, Address["Filter"]> | OakOperation<"remove", Address["RemoveOperationData"], Address["Filter"]>)[];
|
|
station$area?: (OakOperation<"create", Omit<Station["CreateOperationData"], "area"> | Omit<Station["CreateOperationData"], "area">[]> | OakOperation<BaseStation.OpUpdateAction, Omit<Station["UpdateOperationData"], "area">, Station["Filter"]> | OakOperation<"remove", Station["RemoveOperationData"], Station["Filter"]>)[];
|
|
subway$area?: (OakOperation<"create", Omit<Subway["CreateOperationData"], "area"> | Omit<Subway["CreateOperationData"], "area">[]> | OakOperation<BaseSubway.OpUpdateAction, Omit<Subway["UpdateOperationData"], "area">, Subway["Filter"]> | OakOperation<"remove", Subway["RemoveOperationData"], Subway["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseArea.OpUpdateAction, Area["UpdateOperationData"], Area["Filter"], Area["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Area["RemoveOperationData"], Area["Filter"], Area["Sorter"]>;
|
|
Operation: Area["Create"] | Area["Update"] | Area["Remove"];
|
|
};
|
|
export type Article = {
|
|
OpSchema: BaseArticle.OpSchema;
|
|
Action: BaseArticle.OpAction;
|
|
Schema: BaseArticle.OpSchema & {
|
|
articleMenu: ArticleMenu["Schema"];
|
|
extraFile$entity?: Array<Omit<ExtraFile["Schema"], "entity">>;
|
|
extraFile$entity$$aggr?: AggregationResult<Omit<ExtraFile["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseArticle.OpProjection & {
|
|
articleMenu?: ArticleMenu["Projection"];
|
|
extraFile$entity?: OakSelection<"select", Omit<ExtraFile["Projection"], "article">, Omit<ExtraFile["Filter"], "article">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
extraFile$entity$$aggr?: DeduceAggregation<Omit<ExtraFile["Projection"], "article">, Omit<ExtraFile["Filter"], "article">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
};
|
|
FilterUnit: BaseArticle.OpFilter & {
|
|
articleMenu: MakeFilter<ArticleMenu["FilterUnit"]>;
|
|
extraFile$entity: MakeFilter<Omit<ExtraFile["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Article["FilterUnit"]>;
|
|
SortAttr: Partial<BaseArticle.OpSortAttr | {
|
|
articleMenu: ArticleMenu["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Article["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Article["SortNode"][];
|
|
Selection: OakSelection<"select", Article["Projection"], Article["Filter"], Article["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Article["Projection"], Article["Filter"], Article["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseArticle.OpSchema & {
|
|
articleMenu?: OakOperation<"create", ArticleMenu["CreateOperationData"]> | OakOperation<BaseArticleMenu.OpUpdateAction, ArticleMenu["UpdateOperationData"], ArticleMenu["Filter"]>;
|
|
extraFile$entity?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "article"> | Omit<ExtraFile["CreateOperationData"], "article">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "article">, ExtraFile["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Article["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Article["CreateOperationData"]>>;
|
|
Create: Article["CreateSingle"] | Article["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseArticle.OpSchema & {
|
|
articleMenu?: OakOperation<"create", ArticleMenu["CreateOperationData"]> | OakOperation<BaseArticleMenu.OpUpdateAction, ArticleMenu["UpdateOperationData"], ArticleMenu["Filter"]> | OakOperation<"remove", ArticleMenu["RemoveOperationData"], ArticleMenu["Filter"]>;
|
|
extraFile$entity?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "article"> | Omit<ExtraFile["CreateOperationData"], "article">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "article">, ExtraFile["Filter"]> | OakOperation<"remove", ExtraFile["RemoveOperationData"], ExtraFile["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseArticle.OpUpdateAction, Article["UpdateOperationData"], Article["Filter"], Article["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Article["RemoveOperationData"], Article["Filter"], Article["Sorter"]>;
|
|
Operation: Article["Create"] | Article["Update"] | Article["Remove"];
|
|
};
|
|
export type ArticleMenu = {
|
|
OpSchema: BaseArticleMenu.OpSchema;
|
|
Action: BaseArticleMenu.OpAction;
|
|
Schema: BaseArticleMenu.OpSchema & {
|
|
parent?: ArticleMenu["Schema"];
|
|
article$articleMenu?: Array<Omit<Article["Schema"], "articleMenu">>;
|
|
articleMenu$parent?: Array<Omit<ArticleMenu["Schema"], "parent">>;
|
|
extraFile$entity?: Array<Omit<ExtraFile["Schema"], "entity">>;
|
|
article$articleMenu$$aggr?: AggregationResult<Omit<Article["Schema"], "articleMenu">>;
|
|
articleMenu$parent$$aggr?: AggregationResult<Omit<ArticleMenu["Schema"], "parent">>;
|
|
extraFile$entity$$aggr?: AggregationResult<Omit<ExtraFile["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseArticleMenu.OpProjection & {
|
|
parent?: ArticleMenu["Projection"];
|
|
article$articleMenu?: OakSelection<"select", Omit<Article["Projection"], "articleMenu">, Omit<Article["Filter"], "articleMenu">, Article["Sorter"]> & {
|
|
$entity: "article";
|
|
};
|
|
article$articleMenu$$aggr?: DeduceAggregation<Omit<Article["Projection"], "articleMenu">, Omit<Article["Filter"], "articleMenu">, Article["Sorter"]> & {
|
|
$entity: "article";
|
|
};
|
|
articleMenu$parent?: OakSelection<"select", Omit<ArticleMenu["Projection"], "articleMenu">, Omit<ArticleMenu["Filter"], "articleMenu">, ArticleMenu["Sorter"]> & {
|
|
$entity: "articleMenu";
|
|
};
|
|
articleMenu$parent$$aggr?: DeduceAggregation<Omit<ArticleMenu["Projection"], "articleMenu">, Omit<ArticleMenu["Filter"], "articleMenu">, ArticleMenu["Sorter"]> & {
|
|
$entity: "articleMenu";
|
|
};
|
|
extraFile$entity?: OakSelection<"select", Omit<ExtraFile["Projection"], "articleMenu">, Omit<ExtraFile["Filter"], "articleMenu">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
extraFile$entity$$aggr?: DeduceAggregation<Omit<ExtraFile["Projection"], "articleMenu">, Omit<ExtraFile["Filter"], "articleMenu">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
};
|
|
FilterUnit: BaseArticleMenu.OpFilter & {
|
|
parent: MakeFilter<ArticleMenu["FilterUnit"]>;
|
|
article$articleMenu: MakeFilter<Omit<Article["FilterUnit"], "articleMenu">> & SubQueryPredicateMetadata;
|
|
articleMenu$parent: MakeFilter<Omit<ArticleMenu["FilterUnit"], "parent">> & SubQueryPredicateMetadata;
|
|
extraFile$entity: MakeFilter<Omit<ExtraFile["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<ArticleMenu["FilterUnit"]>;
|
|
SortAttr: Partial<BaseArticleMenu.OpSortAttr | {
|
|
parent: ArticleMenu["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ArticleMenu["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ArticleMenu["SortNode"][];
|
|
Selection: OakSelection<"select", ArticleMenu["Projection"], ArticleMenu["Filter"], ArticleMenu["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ArticleMenu["Projection"], ArticleMenu["Filter"], ArticleMenu["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseArticleMenu.OpSchema & {
|
|
parent?: OakOperation<"create", ArticleMenu["CreateOperationData"]> | OakOperation<BaseArticleMenu.OpUpdateAction, ArticleMenu["UpdateOperationData"], ArticleMenu["Filter"]>;
|
|
article$articleMenu?: (OakOperation<"create", Omit<Article["CreateOperationData"], "articleMenu"> | Omit<Article["CreateOperationData"], "articleMenu">[]> | OakOperation<BaseArticle.OpUpdateAction, Omit<Article["UpdateOperationData"], "articleMenu">, Article["Filter"]>)[];
|
|
articleMenu$parent?: (OakOperation<"create", Omit<ArticleMenu["CreateOperationData"], "parent"> | Omit<ArticleMenu["CreateOperationData"], "parent">[]> | OakOperation<BaseArticleMenu.OpUpdateAction, Omit<ArticleMenu["UpdateOperationData"], "parent">, ArticleMenu["Filter"]>)[];
|
|
extraFile$entity?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "articleMenu"> | Omit<ExtraFile["CreateOperationData"], "articleMenu">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "articleMenu">, ExtraFile["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ArticleMenu["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ArticleMenu["CreateOperationData"]>>;
|
|
Create: ArticleMenu["CreateSingle"] | ArticleMenu["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseArticleMenu.OpSchema & {
|
|
parent?: OakOperation<"create", ArticleMenu["CreateOperationData"]> | OakOperation<BaseArticleMenu.OpUpdateAction, ArticleMenu["UpdateOperationData"], ArticleMenu["Filter"]> | OakOperation<"remove", ArticleMenu["RemoveOperationData"], ArticleMenu["Filter"]>;
|
|
article$articleMenu?: (OakOperation<"create", Omit<Article["CreateOperationData"], "articleMenu"> | Omit<Article["CreateOperationData"], "articleMenu">[]> | OakOperation<BaseArticle.OpUpdateAction, Omit<Article["UpdateOperationData"], "articleMenu">, Article["Filter"]> | OakOperation<"remove", Article["RemoveOperationData"], Article["Filter"]>)[];
|
|
articleMenu$parent?: (OakOperation<"create", Omit<ArticleMenu["CreateOperationData"], "parent"> | Omit<ArticleMenu["CreateOperationData"], "parent">[]> | OakOperation<BaseArticleMenu.OpUpdateAction, Omit<ArticleMenu["UpdateOperationData"], "parent">, ArticleMenu["Filter"]> | OakOperation<"remove", ArticleMenu["RemoveOperationData"], ArticleMenu["Filter"]>)[];
|
|
extraFile$entity?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "articleMenu"> | Omit<ExtraFile["CreateOperationData"], "articleMenu">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "articleMenu">, ExtraFile["Filter"]> | OakOperation<"remove", ExtraFile["RemoveOperationData"], ExtraFile["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseArticleMenu.OpUpdateAction, ArticleMenu["UpdateOperationData"], ArticleMenu["Filter"], ArticleMenu["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ArticleMenu["RemoveOperationData"], ArticleMenu["Filter"], ArticleMenu["Sorter"]>;
|
|
Operation: ArticleMenu["Create"] | ArticleMenu["Update"] | ArticleMenu["Remove"];
|
|
};
|
|
export type Captcha = {
|
|
OpSchema: BaseCaptcha.OpSchema;
|
|
Action: BaseCaptcha.OpAction;
|
|
Schema: BaseCaptcha.OpSchema & {
|
|
application?: Application["Schema"];
|
|
};
|
|
Projection: BaseCaptcha.OpProjection & {
|
|
application?: Application["Projection"];
|
|
};
|
|
FilterUnit: BaseCaptcha.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<Captcha["FilterUnit"]>;
|
|
SortAttr: Partial<BaseCaptcha.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Captcha["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Captcha["SortNode"][];
|
|
Selection: OakSelection<"select", Captcha["Projection"], Captcha["Filter"], Captcha["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Captcha["Projection"], Captcha["Filter"], Captcha["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseCaptcha.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Captcha["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Captcha["CreateOperationData"]>>;
|
|
Create: Captcha["CreateSingle"] | Captcha["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseCaptcha.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseCaptcha.OpUpdateAction, Captcha["UpdateOperationData"], Captcha["Filter"], Captcha["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Captcha["RemoveOperationData"], Captcha["Filter"], Captcha["Sorter"]>;
|
|
Operation: Captcha["Create"] | Captcha["Update"] | Captcha["Remove"];
|
|
};
|
|
export type ChangePasswordTemp = {
|
|
OpSchema: BaseChangePasswordTemp.OpSchema;
|
|
Action: BaseChangePasswordTemp.OpAction;
|
|
Schema: BaseChangePasswordTemp.OpSchema & {
|
|
user: User["Schema"];
|
|
};
|
|
Projection: BaseChangePasswordTemp.OpProjection & {
|
|
user?: User["Projection"];
|
|
};
|
|
FilterUnit: BaseChangePasswordTemp.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<ChangePasswordTemp["FilterUnit"]>;
|
|
SortAttr: Partial<BaseChangePasswordTemp.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ChangePasswordTemp["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ChangePasswordTemp["SortNode"][];
|
|
Selection: OakSelection<"select", ChangePasswordTemp["Projection"], ChangePasswordTemp["Filter"], ChangePasswordTemp["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ChangePasswordTemp["Projection"], ChangePasswordTemp["Filter"], ChangePasswordTemp["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseChangePasswordTemp.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ChangePasswordTemp["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ChangePasswordTemp["CreateOperationData"]>>;
|
|
Create: ChangePasswordTemp["CreateSingle"] | ChangePasswordTemp["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseChangePasswordTemp.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseChangePasswordTemp.OpUpdateAction, ChangePasswordTemp["UpdateOperationData"], ChangePasswordTemp["Filter"], ChangePasswordTemp["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ChangePasswordTemp["RemoveOperationData"], ChangePasswordTemp["Filter"], ChangePasswordTemp["Sorter"]>;
|
|
Operation: ChangePasswordTemp["Create"] | ChangePasswordTemp["Update"] | ChangePasswordTemp["Remove"];
|
|
};
|
|
export type Domain = {
|
|
OpSchema: BaseDomain.OpSchema;
|
|
Action: BaseDomain.OpAction;
|
|
Schema: BaseDomain.OpSchema & {
|
|
system: System["Schema"];
|
|
application$domain?: Array<Omit<Application["Schema"], "domain">>;
|
|
application$domain$$aggr?: AggregationResult<Omit<Application["Schema"], "domain">>;
|
|
};
|
|
Projection: BaseDomain.OpProjection & {
|
|
system?: System["Projection"];
|
|
application$domain?: OakSelection<"select", Omit<Application["Projection"], "domain">, Omit<Application["Filter"], "domain">, Application["Sorter"]> & {
|
|
$entity: "application";
|
|
};
|
|
application$domain$$aggr?: DeduceAggregation<Omit<Application["Projection"], "domain">, Omit<Application["Filter"], "domain">, Application["Sorter"]> & {
|
|
$entity: "application";
|
|
};
|
|
};
|
|
FilterUnit: BaseDomain.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
application$domain: MakeFilter<Omit<Application["FilterUnit"], "domain">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Domain["FilterUnit"]>;
|
|
SortAttr: Partial<BaseDomain.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Domain["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Domain["SortNode"][];
|
|
Selection: OakSelection<"select", Domain["Projection"], Domain["Filter"], Domain["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Domain["Projection"], Domain["Filter"], Domain["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseDomain.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
application$domain?: (OakOperation<"create", Omit<Application["CreateOperationData"], "domain"> | Omit<Application["CreateOperationData"], "domain">[]> | OakOperation<BaseApplication.OpUpdateAction, Omit<Application["UpdateOperationData"], "domain">, Application["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Domain["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Domain["CreateOperationData"]>>;
|
|
Create: Domain["CreateSingle"] | Domain["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseDomain.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
application$domain?: (OakOperation<"create", Omit<Application["CreateOperationData"], "domain"> | Omit<Application["CreateOperationData"], "domain">[]> | OakOperation<BaseApplication.OpUpdateAction, Omit<Application["UpdateOperationData"], "domain">, Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseDomain.OpUpdateAction, Domain["UpdateOperationData"], Domain["Filter"], Domain["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Domain["RemoveOperationData"], Domain["Filter"], Domain["Sorter"]>;
|
|
Operation: Domain["Create"] | Domain["Update"] | Domain["Remove"];
|
|
};
|
|
export type Email = {
|
|
OpSchema: BaseEmail.OpSchema;
|
|
Action: BaseEmail.OpAction;
|
|
Schema: BaseEmail.OpSchema & {
|
|
user: User["Schema"];
|
|
token$entity?: Array<Omit<Token["Schema"], "entity">>;
|
|
token$entity$$aggr?: AggregationResult<Omit<Token["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseEmail.OpProjection & {
|
|
user?: User["Projection"];
|
|
token$entity?: OakSelection<"select", Omit<Token["Projection"], "email">, Omit<Token["Filter"], "email">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$entity$$aggr?: DeduceAggregation<Omit<Token["Projection"], "email">, Omit<Token["Filter"], "email">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
};
|
|
FilterUnit: BaseEmail.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
token$entity: MakeFilter<Omit<Token["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Email["FilterUnit"]>;
|
|
SortAttr: Partial<BaseEmail.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Email["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Email["SortNode"][];
|
|
Selection: OakSelection<"select", Email["Projection"], Email["Filter"], Email["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Email["Projection"], Email["Filter"], Email["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseEmail.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "email"> | Omit<Token["CreateOperationData"], "email">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "email">, Token["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Email["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Email["CreateOperationData"]>>;
|
|
Create: Email["CreateSingle"] | Email["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseEmail.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "email"> | Omit<Token["CreateOperationData"], "email">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "email">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseEmail.OpUpdateAction, Email["UpdateOperationData"], Email["Filter"], Email["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Email["RemoveOperationData"], Email["Filter"], Email["Sorter"]>;
|
|
Operation: Email["Create"] | Email["Update"] | Email["Remove"];
|
|
};
|
|
export type ExtraFile = {
|
|
OpSchema: BaseExtraFile.OpSchema;
|
|
Action: BaseExtraFile.OpAction;
|
|
Schema: BaseExtraFile.OpSchema & {
|
|
application: Application["Schema"];
|
|
article?: Article["Schema"];
|
|
articleMenu?: ArticleMenu["Schema"];
|
|
sessionMessage?: SessionMessage["Schema"];
|
|
user?: User["Schema"];
|
|
};
|
|
Projection: BaseExtraFile.OpProjection & {
|
|
application?: Application["Projection"];
|
|
article?: Article["Projection"];
|
|
articleMenu?: ArticleMenu["Projection"];
|
|
sessionMessage?: SessionMessage["Projection"];
|
|
user?: User["Projection"];
|
|
};
|
|
FilterUnit: BaseExtraFile.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
article: MakeFilter<Article["FilterUnit"]>;
|
|
articleMenu: MakeFilter<ArticleMenu["FilterUnit"]>;
|
|
sessionMessage: MakeFilter<SessionMessage["FilterUnit"]>;
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<ExtraFile["FilterUnit"]>;
|
|
SortAttr: Partial<BaseExtraFile.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
article: Article["SortAttr"];
|
|
articleMenu: ArticleMenu["SortAttr"];
|
|
sessionMessage: SessionMessage["SortAttr"];
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ExtraFile["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ExtraFile["SortNode"][];
|
|
Selection: OakSelection<"select", ExtraFile["Projection"], ExtraFile["Filter"], ExtraFile["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ExtraFile["Projection"], ExtraFile["Filter"], ExtraFile["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseExtraFile.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
article?: OakOperation<"create", Article["CreateOperationData"]> | OakOperation<BaseArticle.OpUpdateAction, Article["UpdateOperationData"], Article["Filter"]>;
|
|
articleMenu?: OakOperation<"create", ArticleMenu["CreateOperationData"]> | OakOperation<BaseArticleMenu.OpUpdateAction, ArticleMenu["UpdateOperationData"], ArticleMenu["Filter"]>;
|
|
sessionMessage?: OakOperation<"create", SessionMessage["CreateOperationData"]> | OakOperation<BaseSessionMessage.OpUpdateAction, SessionMessage["UpdateOperationData"], SessionMessage["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ExtraFile["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ExtraFile["CreateOperationData"]>>;
|
|
Create: ExtraFile["CreateSingle"] | ExtraFile["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseExtraFile.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
article?: OakOperation<"create", Article["CreateOperationData"]> | OakOperation<BaseArticle.OpUpdateAction, Article["UpdateOperationData"], Article["Filter"]> | OakOperation<"remove", Article["RemoveOperationData"], Article["Filter"]>;
|
|
articleMenu?: OakOperation<"create", ArticleMenu["CreateOperationData"]> | OakOperation<BaseArticleMenu.OpUpdateAction, ArticleMenu["UpdateOperationData"], ArticleMenu["Filter"]> | OakOperation<"remove", ArticleMenu["RemoveOperationData"], ArticleMenu["Filter"]>;
|
|
sessionMessage?: OakOperation<"create", SessionMessage["CreateOperationData"]> | OakOperation<BaseSessionMessage.OpUpdateAction, SessionMessage["UpdateOperationData"], SessionMessage["Filter"]> | OakOperation<"remove", SessionMessage["RemoveOperationData"], SessionMessage["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseExtraFile.OpUpdateAction, ExtraFile["UpdateOperationData"], ExtraFile["Filter"], ExtraFile["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ExtraFile["RemoveOperationData"], ExtraFile["Filter"], ExtraFile["Sorter"]>;
|
|
Operation: ExtraFile["Create"] | ExtraFile["Update"] | ExtraFile["Remove"];
|
|
};
|
|
export type Livestream = {
|
|
OpSchema: BaseLivestream.OpSchema;
|
|
Action: BaseLivestream.OpAction;
|
|
Schema: BaseLivestream.OpSchema & {};
|
|
Projection: BaseLivestream.OpProjection & {};
|
|
FilterUnit: BaseLivestream.OpFilter & {};
|
|
Filter: MakeFilter<Livestream["FilterUnit"]>;
|
|
SortAttr: Partial<BaseLivestream.OpSortAttr | {}>;
|
|
SortNode: {
|
|
$attr: Livestream["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Livestream["SortNode"][];
|
|
Selection: OakSelection<"select", Livestream["Projection"], Livestream["Filter"], Livestream["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Livestream["Projection"], Livestream["Filter"], Livestream["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseLivestream.OpSchema>;
|
|
CreateSingle: OakOperation<"create", Livestream["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Livestream["CreateOperationData"]>>;
|
|
Create: Livestream["CreateSingle"] | Livestream["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseLivestream.OpSchema>;
|
|
Update: OakOperation<BaseLivestream.OpUpdateAction, Livestream["UpdateOperationData"], Livestream["Filter"], Livestream["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Livestream["RemoveOperationData"], Livestream["Filter"], Livestream["Sorter"]>;
|
|
Operation: Livestream["Create"] | Livestream["Update"] | Livestream["Remove"];
|
|
};
|
|
export type LoginName = {
|
|
OpSchema: BaseLoginName.OpSchema;
|
|
Action: BaseLoginName.OpAction;
|
|
Schema: BaseLoginName.OpSchema & {
|
|
user: User["Schema"];
|
|
token$entity?: Array<Omit<Token["Schema"], "entity">>;
|
|
token$entity$$aggr?: AggregationResult<Omit<Token["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseLoginName.OpProjection & {
|
|
user?: User["Projection"];
|
|
token$entity?: OakSelection<"select", Omit<Token["Projection"], "loginName">, Omit<Token["Filter"], "loginName">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$entity$$aggr?: DeduceAggregation<Omit<Token["Projection"], "loginName">, Omit<Token["Filter"], "loginName">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
};
|
|
FilterUnit: BaseLoginName.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
token$entity: MakeFilter<Omit<Token["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<LoginName["FilterUnit"]>;
|
|
SortAttr: Partial<BaseLoginName.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: LoginName["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: LoginName["SortNode"][];
|
|
Selection: OakSelection<"select", LoginName["Projection"], LoginName["Filter"], LoginName["Sorter"]>;
|
|
Aggregation: DeduceAggregation<LoginName["Projection"], LoginName["Filter"], LoginName["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseLoginName.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "loginName"> | Omit<Token["CreateOperationData"], "loginName">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "loginName">, Token["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", LoginName["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<LoginName["CreateOperationData"]>>;
|
|
Create: LoginName["CreateSingle"] | LoginName["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseLoginName.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "loginName"> | Omit<Token["CreateOperationData"], "loginName">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "loginName">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseLoginName.OpUpdateAction, LoginName["UpdateOperationData"], LoginName["Filter"], LoginName["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", LoginName["RemoveOperationData"], LoginName["Filter"], LoginName["Sorter"]>;
|
|
Operation: LoginName["Create"] | LoginName["Update"] | LoginName["Remove"];
|
|
};
|
|
export type Message = {
|
|
OpSchema: BaseMessage.OpSchema;
|
|
Action: BaseMessage.OpAction;
|
|
Schema: BaseMessage.OpSchema & {
|
|
user: User["Schema"];
|
|
platform?: Platform["Schema"];
|
|
messageSystem$message?: Array<Omit<MessageSystem["Schema"], "message">>;
|
|
wechatMpJump$message?: Array<Omit<WechatMpJump["Schema"], "message">>;
|
|
messageSystem$message$$aggr?: AggregationResult<Omit<MessageSystem["Schema"], "message">>;
|
|
wechatMpJump$message$$aggr?: AggregationResult<Omit<WechatMpJump["Schema"], "message">>;
|
|
};
|
|
Projection: BaseMessage.OpProjection & {
|
|
user?: User["Projection"];
|
|
platform?: Platform["Projection"];
|
|
messageSystem$message?: OakSelection<"select", Omit<MessageSystem["Projection"], "message">, Omit<MessageSystem["Filter"], "message">, MessageSystem["Sorter"]> & {
|
|
$entity: "messageSystem";
|
|
};
|
|
messageSystem$message$$aggr?: DeduceAggregation<Omit<MessageSystem["Projection"], "message">, Omit<MessageSystem["Filter"], "message">, MessageSystem["Sorter"]> & {
|
|
$entity: "messageSystem";
|
|
};
|
|
wechatMpJump$message?: OakSelection<"select", Omit<WechatMpJump["Projection"], "message">, Omit<WechatMpJump["Filter"], "message">, WechatMpJump["Sorter"]> & {
|
|
$entity: "wechatMpJump";
|
|
};
|
|
wechatMpJump$message$$aggr?: DeduceAggregation<Omit<WechatMpJump["Projection"], "message">, Omit<WechatMpJump["Filter"], "message">, WechatMpJump["Sorter"]> & {
|
|
$entity: "wechatMpJump";
|
|
};
|
|
};
|
|
FilterUnit: BaseMessage.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
platform: MakeFilter<Platform["FilterUnit"]>;
|
|
messageSystem$message: MakeFilter<Omit<MessageSystem["FilterUnit"], "message">> & SubQueryPredicateMetadata;
|
|
wechatMpJump$message: MakeFilter<Omit<WechatMpJump["FilterUnit"], "message">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Message["FilterUnit"]>;
|
|
SortAttr: Partial<BaseMessage.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
platform: Platform["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Message["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Message["SortNode"][];
|
|
Selection: OakSelection<"select", Message["Projection"], Message["Filter"], Message["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Message["Projection"], Message["Filter"], Message["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseMessage.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
platform?: OakOperation<"create", Platform["CreateOperationData"]> | OakOperation<BasePlatform.OpUpdateAction, Platform["UpdateOperationData"], Platform["Filter"]>;
|
|
messageSystem$message?: (OakOperation<"create", Omit<MessageSystem["CreateOperationData"], "message"> | Omit<MessageSystem["CreateOperationData"], "message">[]> | OakOperation<BaseMessageSystem.OpUpdateAction, Omit<MessageSystem["UpdateOperationData"], "message">, MessageSystem["Filter"]>)[];
|
|
wechatMpJump$message?: (OakOperation<"create", Omit<WechatMpJump["CreateOperationData"], "message"> | Omit<WechatMpJump["CreateOperationData"], "message">[]> | OakOperation<BaseWechatMpJump.OpUpdateAction, Omit<WechatMpJump["UpdateOperationData"], "message">, WechatMpJump["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Message["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Message["CreateOperationData"]>>;
|
|
Create: Message["CreateSingle"] | Message["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseMessage.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
platform?: OakOperation<"create", Platform["CreateOperationData"]> | OakOperation<BasePlatform.OpUpdateAction, Platform["UpdateOperationData"], Platform["Filter"]> | OakOperation<"remove", Platform["RemoveOperationData"], Platform["Filter"]>;
|
|
messageSystem$message?: (OakOperation<"create", Omit<MessageSystem["CreateOperationData"], "message"> | Omit<MessageSystem["CreateOperationData"], "message">[]> | OakOperation<BaseMessageSystem.OpUpdateAction, Omit<MessageSystem["UpdateOperationData"], "message">, MessageSystem["Filter"]> | OakOperation<"remove", MessageSystem["RemoveOperationData"], MessageSystem["Filter"]>)[];
|
|
wechatMpJump$message?: (OakOperation<"create", Omit<WechatMpJump["CreateOperationData"], "message"> | Omit<WechatMpJump["CreateOperationData"], "message">[]> | OakOperation<BaseWechatMpJump.OpUpdateAction, Omit<WechatMpJump["UpdateOperationData"], "message">, WechatMpJump["Filter"]> | OakOperation<"remove", WechatMpJump["RemoveOperationData"], WechatMpJump["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseMessage.OpUpdateAction, Message["UpdateOperationData"], Message["Filter"], Message["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Message["RemoveOperationData"], Message["Filter"], Message["Sorter"]>;
|
|
Operation: Message["Create"] | Message["Update"] | Message["Remove"];
|
|
};
|
|
export type MessageSystem = {
|
|
OpSchema: BaseMessageSystem.OpSchema;
|
|
Action: BaseMessageSystem.OpAction;
|
|
Schema: BaseMessageSystem.OpSchema & {
|
|
message: Message["Schema"];
|
|
system: System["Schema"];
|
|
notification$messageSystem?: Array<Omit<Notification["Schema"], "messageSystem">>;
|
|
notification$messageSystem$$aggr?: AggregationResult<Omit<Notification["Schema"], "messageSystem">>;
|
|
};
|
|
Projection: BaseMessageSystem.OpProjection & {
|
|
message?: Message["Projection"];
|
|
system?: System["Projection"];
|
|
notification$messageSystem?: OakSelection<"select", Omit<Notification["Projection"], "messageSystem">, Omit<Notification["Filter"], "messageSystem">, Notification["Sorter"]> & {
|
|
$entity: "notification";
|
|
};
|
|
notification$messageSystem$$aggr?: DeduceAggregation<Omit<Notification["Projection"], "messageSystem">, Omit<Notification["Filter"], "messageSystem">, Notification["Sorter"]> & {
|
|
$entity: "notification";
|
|
};
|
|
};
|
|
FilterUnit: BaseMessageSystem.OpFilter & {
|
|
message: MakeFilter<Message["FilterUnit"]>;
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
notification$messageSystem: MakeFilter<Omit<Notification["FilterUnit"], "messageSystem">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<MessageSystem["FilterUnit"]>;
|
|
SortAttr: Partial<BaseMessageSystem.OpSortAttr | {
|
|
message: Message["SortAttr"];
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: MessageSystem["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: MessageSystem["SortNode"][];
|
|
Selection: OakSelection<"select", MessageSystem["Projection"], MessageSystem["Filter"], MessageSystem["Sorter"]>;
|
|
Aggregation: DeduceAggregation<MessageSystem["Projection"], MessageSystem["Filter"], MessageSystem["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseMessageSystem.OpSchema & {
|
|
message?: OakOperation<"create", Message["CreateOperationData"]> | OakOperation<BaseMessage.OpUpdateAction, Message["UpdateOperationData"], Message["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
notification$messageSystem?: (OakOperation<"create", Omit<Notification["CreateOperationData"], "messageSystem"> | Omit<Notification["CreateOperationData"], "messageSystem">[]> | OakOperation<BaseNotification.OpUpdateAction, Omit<Notification["UpdateOperationData"], "messageSystem">, Notification["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", MessageSystem["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<MessageSystem["CreateOperationData"]>>;
|
|
Create: MessageSystem["CreateSingle"] | MessageSystem["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseMessageSystem.OpSchema & {
|
|
message?: OakOperation<"create", Message["CreateOperationData"]> | OakOperation<BaseMessage.OpUpdateAction, Message["UpdateOperationData"], Message["Filter"]> | OakOperation<"remove", Message["RemoveOperationData"], Message["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
notification$messageSystem?: (OakOperation<"create", Omit<Notification["CreateOperationData"], "messageSystem"> | Omit<Notification["CreateOperationData"], "messageSystem">[]> | OakOperation<BaseNotification.OpUpdateAction, Omit<Notification["UpdateOperationData"], "messageSystem">, Notification["Filter"]> | OakOperation<"remove", Notification["RemoveOperationData"], Notification["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseMessageSystem.OpUpdateAction, MessageSystem["UpdateOperationData"], MessageSystem["Filter"], MessageSystem["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", MessageSystem["RemoveOperationData"], MessageSystem["Filter"], MessageSystem["Sorter"]>;
|
|
Operation: MessageSystem["Create"] | MessageSystem["Update"] | MessageSystem["Remove"];
|
|
};
|
|
export type MessageType = {
|
|
OpSchema: BaseMessageType.OpSchema;
|
|
Action: BaseMessageType.OpAction;
|
|
Schema: BaseMessageType.OpSchema & {};
|
|
Projection: BaseMessageType.OpProjection & {};
|
|
FilterUnit: BaseMessageType.OpFilter & {};
|
|
Filter: MakeFilter<MessageType["FilterUnit"]>;
|
|
SortAttr: Partial<BaseMessageType.OpSortAttr | {}>;
|
|
SortNode: {
|
|
$attr: MessageType["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: MessageType["SortNode"][];
|
|
Selection: OakSelection<"select", MessageType["Projection"], MessageType["Filter"], MessageType["Sorter"]>;
|
|
Aggregation: DeduceAggregation<MessageType["Projection"], MessageType["Filter"], MessageType["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseMessageType.OpSchema>;
|
|
CreateSingle: OakOperation<"create", MessageType["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<MessageType["CreateOperationData"]>>;
|
|
Create: MessageType["CreateSingle"] | MessageType["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseMessageType.OpSchema>;
|
|
Update: OakOperation<BaseMessageType.OpUpdateAction, MessageType["UpdateOperationData"], MessageType["Filter"], MessageType["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", MessageType["RemoveOperationData"], MessageType["Filter"], MessageType["Sorter"]>;
|
|
Operation: MessageType["Create"] | MessageType["Update"] | MessageType["Remove"];
|
|
};
|
|
export type MessageTypeSmsTemplate = {
|
|
OpSchema: BaseMessageTypeSmsTemplate.OpSchema;
|
|
Action: BaseMessageTypeSmsTemplate.OpAction;
|
|
Schema: BaseMessageTypeSmsTemplate.OpSchema & {
|
|
template: SmsTemplate["Schema"];
|
|
};
|
|
Projection: BaseMessageTypeSmsTemplate.OpProjection & {
|
|
template?: SmsTemplate["Projection"];
|
|
};
|
|
FilterUnit: BaseMessageTypeSmsTemplate.OpFilter & {
|
|
template: MakeFilter<SmsTemplate["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<MessageTypeSmsTemplate["FilterUnit"]>;
|
|
SortAttr: Partial<BaseMessageTypeSmsTemplate.OpSortAttr | {
|
|
template: SmsTemplate["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: MessageTypeSmsTemplate["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: MessageTypeSmsTemplate["SortNode"][];
|
|
Selection: OakSelection<"select", MessageTypeSmsTemplate["Projection"], MessageTypeSmsTemplate["Filter"], MessageTypeSmsTemplate["Sorter"]>;
|
|
Aggregation: DeduceAggregation<MessageTypeSmsTemplate["Projection"], MessageTypeSmsTemplate["Filter"], MessageTypeSmsTemplate["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseMessageTypeSmsTemplate.OpSchema & {
|
|
template?: OakOperation<"create", SmsTemplate["CreateOperationData"]> | OakOperation<BaseSmsTemplate.OpUpdateAction, SmsTemplate["UpdateOperationData"], SmsTemplate["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", MessageTypeSmsTemplate["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<MessageTypeSmsTemplate["CreateOperationData"]>>;
|
|
Create: MessageTypeSmsTemplate["CreateSingle"] | MessageTypeSmsTemplate["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseMessageTypeSmsTemplate.OpSchema & {
|
|
template?: OakOperation<"create", SmsTemplate["CreateOperationData"]> | OakOperation<BaseSmsTemplate.OpUpdateAction, SmsTemplate["UpdateOperationData"], SmsTemplate["Filter"]> | OakOperation<"remove", SmsTemplate["RemoveOperationData"], SmsTemplate["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseMessageTypeSmsTemplate.OpUpdateAction, MessageTypeSmsTemplate["UpdateOperationData"], MessageTypeSmsTemplate["Filter"], MessageTypeSmsTemplate["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", MessageTypeSmsTemplate["RemoveOperationData"], MessageTypeSmsTemplate["Filter"], MessageTypeSmsTemplate["Sorter"]>;
|
|
Operation: MessageTypeSmsTemplate["Create"] | MessageTypeSmsTemplate["Update"] | MessageTypeSmsTemplate["Remove"];
|
|
};
|
|
export type MessageTypeTemplate = {
|
|
OpSchema: BaseMessageTypeTemplate.OpSchema;
|
|
Action: BaseMessageTypeTemplate.OpAction;
|
|
Schema: BaseMessageTypeTemplate.OpSchema & {
|
|
template: WechatTemplate["Schema"];
|
|
};
|
|
Projection: BaseMessageTypeTemplate.OpProjection & {
|
|
template?: WechatTemplate["Projection"];
|
|
};
|
|
FilterUnit: BaseMessageTypeTemplate.OpFilter & {
|
|
template: MakeFilter<WechatTemplate["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<MessageTypeTemplate["FilterUnit"]>;
|
|
SortAttr: Partial<BaseMessageTypeTemplate.OpSortAttr | {
|
|
template: WechatTemplate["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: MessageTypeTemplate["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: MessageTypeTemplate["SortNode"][];
|
|
Selection: OakSelection<"select", MessageTypeTemplate["Projection"], MessageTypeTemplate["Filter"], MessageTypeTemplate["Sorter"]>;
|
|
Aggregation: DeduceAggregation<MessageTypeTemplate["Projection"], MessageTypeTemplate["Filter"], MessageTypeTemplate["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseMessageTypeTemplate.OpSchema & {
|
|
template?: OakOperation<"create", WechatTemplate["CreateOperationData"]> | OakOperation<BaseWechatTemplate.OpUpdateAction, WechatTemplate["UpdateOperationData"], WechatTemplate["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", MessageTypeTemplate["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<MessageTypeTemplate["CreateOperationData"]>>;
|
|
Create: MessageTypeTemplate["CreateSingle"] | MessageTypeTemplate["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseMessageTypeTemplate.OpSchema & {
|
|
template?: OakOperation<"create", WechatTemplate["CreateOperationData"]> | OakOperation<BaseWechatTemplate.OpUpdateAction, WechatTemplate["UpdateOperationData"], WechatTemplate["Filter"]> | OakOperation<"remove", WechatTemplate["RemoveOperationData"], WechatTemplate["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseMessageTypeTemplate.OpUpdateAction, MessageTypeTemplate["UpdateOperationData"], MessageTypeTemplate["Filter"], MessageTypeTemplate["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", MessageTypeTemplate["RemoveOperationData"], MessageTypeTemplate["Filter"], MessageTypeTemplate["Sorter"]>;
|
|
Operation: MessageTypeTemplate["Create"] | MessageTypeTemplate["Update"] | MessageTypeTemplate["Remove"];
|
|
};
|
|
export type Mobile = {
|
|
OpSchema: BaseMobile.OpSchema;
|
|
Action: BaseMobile.OpAction;
|
|
Schema: BaseMobile.OpSchema & {
|
|
user?: User["Schema"];
|
|
token$entity?: Array<Omit<Token["Schema"], "entity">>;
|
|
token$entity$$aggr?: AggregationResult<Omit<Token["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseMobile.OpProjection & {
|
|
user?: User["Projection"];
|
|
token$entity?: OakSelection<"select", Omit<Token["Projection"], "mobile">, Omit<Token["Filter"], "mobile">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$entity$$aggr?: DeduceAggregation<Omit<Token["Projection"], "mobile">, Omit<Token["Filter"], "mobile">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
};
|
|
FilterUnit: BaseMobile.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
token$entity: MakeFilter<Omit<Token["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Mobile["FilterUnit"]>;
|
|
SortAttr: Partial<BaseMobile.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Mobile["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Mobile["SortNode"][];
|
|
Selection: OakSelection<"select", Mobile["Projection"], Mobile["Filter"], Mobile["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Mobile["Projection"], Mobile["Filter"], Mobile["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseMobile.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "mobile"> | Omit<Token["CreateOperationData"], "mobile">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "mobile">, Token["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Mobile["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Mobile["CreateOperationData"]>>;
|
|
Create: Mobile["CreateSingle"] | Mobile["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseMobile.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "mobile"> | Omit<Token["CreateOperationData"], "mobile">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "mobile">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseMobile.OpUpdateAction, Mobile["UpdateOperationData"], Mobile["Filter"], Mobile["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Mobile["RemoveOperationData"], Mobile["Filter"], Mobile["Sorter"]>;
|
|
Operation: Mobile["Create"] | Mobile["Update"] | Mobile["Remove"];
|
|
};
|
|
export type Notification = {
|
|
OpSchema: BaseNotification.OpSchema;
|
|
Action: BaseNotification.OpAction;
|
|
Schema: BaseNotification.OpSchema & {
|
|
application?: Application["Schema"];
|
|
messageSystem: MessageSystem["Schema"];
|
|
};
|
|
Projection: BaseNotification.OpProjection & {
|
|
application?: Application["Projection"];
|
|
messageSystem?: MessageSystem["Projection"];
|
|
};
|
|
FilterUnit: BaseNotification.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
messageSystem: MakeFilter<MessageSystem["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<Notification["FilterUnit"]>;
|
|
SortAttr: Partial<BaseNotification.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
messageSystem: MessageSystem["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Notification["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Notification["SortNode"][];
|
|
Selection: OakSelection<"select", Notification["Projection"], Notification["Filter"], Notification["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Notification["Projection"], Notification["Filter"], Notification["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseNotification.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
messageSystem?: OakOperation<"create", MessageSystem["CreateOperationData"]> | OakOperation<BaseMessageSystem.OpUpdateAction, MessageSystem["UpdateOperationData"], MessageSystem["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Notification["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Notification["CreateOperationData"]>>;
|
|
Create: Notification["CreateSingle"] | Notification["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseNotification.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
messageSystem?: OakOperation<"create", MessageSystem["CreateOperationData"]> | OakOperation<BaseMessageSystem.OpUpdateAction, MessageSystem["UpdateOperationData"], MessageSystem["Filter"]> | OakOperation<"remove", MessageSystem["RemoveOperationData"], MessageSystem["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseNotification.OpUpdateAction, Notification["UpdateOperationData"], Notification["Filter"], Notification["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Notification["RemoveOperationData"], Notification["Filter"], Notification["Sorter"]>;
|
|
Operation: Notification["Create"] | Notification["Update"] | Notification["Remove"];
|
|
};
|
|
export type OauthApplication = {
|
|
OpSchema: BaseOauthApplication.OpSchema;
|
|
Action: BaseOauthApplication.OpAction;
|
|
Schema: BaseOauthApplication.OpSchema & {
|
|
system: System["Schema"];
|
|
oauthAuthorizationCode$oauthApp?: Array<Omit<OauthAuthorizationCode["Schema"], "oauthApp">>;
|
|
oauthUserAuthorization$application?: Array<Omit<OauthUserAuthorization["Schema"], "application">>;
|
|
oauthAuthorizationCode$oauthApp$$aggr?: AggregationResult<Omit<OauthAuthorizationCode["Schema"], "oauthApp">>;
|
|
oauthUserAuthorization$application$$aggr?: AggregationResult<Omit<OauthUserAuthorization["Schema"], "application">>;
|
|
};
|
|
Projection: BaseOauthApplication.OpProjection & {
|
|
system?: System["Projection"];
|
|
oauthAuthorizationCode$oauthApp?: OakSelection<"select", Omit<OauthAuthorizationCode["Projection"], "oauthApplication">, Omit<OauthAuthorizationCode["Filter"], "oauthApplication">, OauthAuthorizationCode["Sorter"]> & {
|
|
$entity: "oauthAuthorizationCode";
|
|
};
|
|
oauthAuthorizationCode$oauthApp$$aggr?: DeduceAggregation<Omit<OauthAuthorizationCode["Projection"], "oauthApplication">, Omit<OauthAuthorizationCode["Filter"], "oauthApplication">, OauthAuthorizationCode["Sorter"]> & {
|
|
$entity: "oauthAuthorizationCode";
|
|
};
|
|
oauthUserAuthorization$application?: OakSelection<"select", Omit<OauthUserAuthorization["Projection"], "oauthApplication">, Omit<OauthUserAuthorization["Filter"], "oauthApplication">, OauthUserAuthorization["Sorter"]> & {
|
|
$entity: "oauthUserAuthorization";
|
|
};
|
|
oauthUserAuthorization$application$$aggr?: DeduceAggregation<Omit<OauthUserAuthorization["Projection"], "oauthApplication">, Omit<OauthUserAuthorization["Filter"], "oauthApplication">, OauthUserAuthorization["Sorter"]> & {
|
|
$entity: "oauthUserAuthorization";
|
|
};
|
|
};
|
|
FilterUnit: BaseOauthApplication.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
oauthAuthorizationCode$oauthApp: MakeFilter<Omit<OauthAuthorizationCode["FilterUnit"], "oauthApp">> & SubQueryPredicateMetadata;
|
|
oauthUserAuthorization$application: MakeFilter<Omit<OauthUserAuthorization["FilterUnit"], "application">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<OauthApplication["FilterUnit"]>;
|
|
SortAttr: Partial<BaseOauthApplication.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: OauthApplication["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: OauthApplication["SortNode"][];
|
|
Selection: OakSelection<"select", OauthApplication["Projection"], OauthApplication["Filter"], OauthApplication["Sorter"]>;
|
|
Aggregation: DeduceAggregation<OauthApplication["Projection"], OauthApplication["Filter"], OauthApplication["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseOauthApplication.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
oauthAuthorizationCode$oauthApp?: (OakOperation<"create", Omit<OauthAuthorizationCode["CreateOperationData"], "oauthApp"> | Omit<OauthAuthorizationCode["CreateOperationData"], "oauthApp">[]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, Omit<OauthAuthorizationCode["UpdateOperationData"], "oauthApp">, OauthAuthorizationCode["Filter"]>)[];
|
|
oauthUserAuthorization$application?: (OakOperation<"create", Omit<OauthUserAuthorization["CreateOperationData"], "application"> | Omit<OauthUserAuthorization["CreateOperationData"], "application">[]> | OakOperation<BaseOauthUserAuthorization.OpUpdateAction, Omit<OauthUserAuthorization["UpdateOperationData"], "application">, OauthUserAuthorization["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", OauthApplication["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<OauthApplication["CreateOperationData"]>>;
|
|
Create: OauthApplication["CreateSingle"] | OauthApplication["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseOauthApplication.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
oauthAuthorizationCode$oauthApp?: (OakOperation<"create", Omit<OauthAuthorizationCode["CreateOperationData"], "oauthApp"> | Omit<OauthAuthorizationCode["CreateOperationData"], "oauthApp">[]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, Omit<OauthAuthorizationCode["UpdateOperationData"], "oauthApp">, OauthAuthorizationCode["Filter"]> | OakOperation<"remove", OauthAuthorizationCode["RemoveOperationData"], OauthAuthorizationCode["Filter"]>)[];
|
|
oauthUserAuthorization$application?: (OakOperation<"create", Omit<OauthUserAuthorization["CreateOperationData"], "application"> | Omit<OauthUserAuthorization["CreateOperationData"], "application">[]> | OakOperation<BaseOauthUserAuthorization.OpUpdateAction, Omit<OauthUserAuthorization["UpdateOperationData"], "application">, OauthUserAuthorization["Filter"]> | OakOperation<"remove", OauthUserAuthorization["RemoveOperationData"], OauthUserAuthorization["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseOauthApplication.OpUpdateAction, OauthApplication["UpdateOperationData"], OauthApplication["Filter"], OauthApplication["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", OauthApplication["RemoveOperationData"], OauthApplication["Filter"], OauthApplication["Sorter"]>;
|
|
Operation: OauthApplication["Create"] | OauthApplication["Update"] | OauthApplication["Remove"];
|
|
};
|
|
export type OauthAuthorizationCode = {
|
|
OpSchema: BaseOauthAuthorizationCode.OpSchema;
|
|
Action: BaseOauthAuthorizationCode.OpAction;
|
|
Schema: BaseOauthAuthorizationCode.OpSchema & {
|
|
application: Application["Schema"];
|
|
oauthApp: OauthApplication["Schema"];
|
|
user: User["Schema"];
|
|
oauthToken$code?: Array<Omit<OauthToken["Schema"], "code">>;
|
|
oauthUserAuthorization$code?: Array<Omit<OauthUserAuthorization["Schema"], "code">>;
|
|
oauthToken$code$$aggr?: AggregationResult<Omit<OauthToken["Schema"], "code">>;
|
|
oauthUserAuthorization$code$$aggr?: AggregationResult<Omit<OauthUserAuthorization["Schema"], "code">>;
|
|
};
|
|
Projection: BaseOauthAuthorizationCode.OpProjection & {
|
|
application?: Application["Projection"];
|
|
oauthApp?: OauthApplication["Projection"];
|
|
user?: User["Projection"];
|
|
oauthToken$code?: OakSelection<"select", Omit<OauthToken["Projection"], "oauthAuthorizationCode">, Omit<OauthToken["Filter"], "oauthAuthorizationCode">, OauthToken["Sorter"]> & {
|
|
$entity: "oauthToken";
|
|
};
|
|
oauthToken$code$$aggr?: DeduceAggregation<Omit<OauthToken["Projection"], "oauthAuthorizationCode">, Omit<OauthToken["Filter"], "oauthAuthorizationCode">, OauthToken["Sorter"]> & {
|
|
$entity: "oauthToken";
|
|
};
|
|
oauthUserAuthorization$code?: OakSelection<"select", Omit<OauthUserAuthorization["Projection"], "oauthAuthorizationCode">, Omit<OauthUserAuthorization["Filter"], "oauthAuthorizationCode">, OauthUserAuthorization["Sorter"]> & {
|
|
$entity: "oauthUserAuthorization";
|
|
};
|
|
oauthUserAuthorization$code$$aggr?: DeduceAggregation<Omit<OauthUserAuthorization["Projection"], "oauthAuthorizationCode">, Omit<OauthUserAuthorization["Filter"], "oauthAuthorizationCode">, OauthUserAuthorization["Sorter"]> & {
|
|
$entity: "oauthUserAuthorization";
|
|
};
|
|
};
|
|
FilterUnit: BaseOauthAuthorizationCode.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
oauthApp: MakeFilter<OauthApplication["FilterUnit"]>;
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
oauthToken$code: MakeFilter<Omit<OauthToken["FilterUnit"], "code">> & SubQueryPredicateMetadata;
|
|
oauthUserAuthorization$code: MakeFilter<Omit<OauthUserAuthorization["FilterUnit"], "code">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<OauthAuthorizationCode["FilterUnit"]>;
|
|
SortAttr: Partial<BaseOauthAuthorizationCode.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
oauthApp: OauthApplication["SortAttr"];
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: OauthAuthorizationCode["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: OauthAuthorizationCode["SortNode"][];
|
|
Selection: OakSelection<"select", OauthAuthorizationCode["Projection"], OauthAuthorizationCode["Filter"], OauthAuthorizationCode["Sorter"]>;
|
|
Aggregation: DeduceAggregation<OauthAuthorizationCode["Projection"], OauthAuthorizationCode["Filter"], OauthAuthorizationCode["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseOauthAuthorizationCode.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
oauthApp?: OakOperation<"create", OauthApplication["CreateOperationData"]> | OakOperation<BaseOauthApplication.OpUpdateAction, OauthApplication["UpdateOperationData"], OauthApplication["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
oauthToken$code?: (OakOperation<"create", Omit<OauthToken["CreateOperationData"], "code"> | Omit<OauthToken["CreateOperationData"], "code">[]> | OakOperation<BaseOauthToken.OpUpdateAction, Omit<OauthToken["UpdateOperationData"], "code">, OauthToken["Filter"]>)[];
|
|
oauthUserAuthorization$code?: (OakOperation<"create", Omit<OauthUserAuthorization["CreateOperationData"], "code"> | Omit<OauthUserAuthorization["CreateOperationData"], "code">[]> | OakOperation<BaseOauthUserAuthorization.OpUpdateAction, Omit<OauthUserAuthorization["UpdateOperationData"], "code">, OauthUserAuthorization["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", OauthAuthorizationCode["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<OauthAuthorizationCode["CreateOperationData"]>>;
|
|
Create: OauthAuthorizationCode["CreateSingle"] | OauthAuthorizationCode["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseOauthAuthorizationCode.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
oauthApp?: OakOperation<"create", OauthApplication["CreateOperationData"]> | OakOperation<BaseOauthApplication.OpUpdateAction, OauthApplication["UpdateOperationData"], OauthApplication["Filter"]> | OakOperation<"remove", OauthApplication["RemoveOperationData"], OauthApplication["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
oauthToken$code?: (OakOperation<"create", Omit<OauthToken["CreateOperationData"], "code"> | Omit<OauthToken["CreateOperationData"], "code">[]> | OakOperation<BaseOauthToken.OpUpdateAction, Omit<OauthToken["UpdateOperationData"], "code">, OauthToken["Filter"]> | OakOperation<"remove", OauthToken["RemoveOperationData"], OauthToken["Filter"]>)[];
|
|
oauthUserAuthorization$code?: (OakOperation<"create", Omit<OauthUserAuthorization["CreateOperationData"], "code"> | Omit<OauthUserAuthorization["CreateOperationData"], "code">[]> | OakOperation<BaseOauthUserAuthorization.OpUpdateAction, Omit<OauthUserAuthorization["UpdateOperationData"], "code">, OauthUserAuthorization["Filter"]> | OakOperation<"remove", OauthUserAuthorization["RemoveOperationData"], OauthUserAuthorization["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, OauthAuthorizationCode["UpdateOperationData"], OauthAuthorizationCode["Filter"], OauthAuthorizationCode["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", OauthAuthorizationCode["RemoveOperationData"], OauthAuthorizationCode["Filter"], OauthAuthorizationCode["Sorter"]>;
|
|
Operation: OauthAuthorizationCode["Create"] | OauthAuthorizationCode["Update"] | OauthAuthorizationCode["Remove"];
|
|
};
|
|
export type OauthProvider = {
|
|
OpSchema: BaseOauthProvider.OpSchema;
|
|
Action: BaseOauthProvider.OpAction;
|
|
Schema: BaseOauthProvider.OpSchema & {
|
|
system: System["Schema"];
|
|
oauthState$provider?: Array<Omit<OauthState["Schema"], "provider">>;
|
|
oauthUser$providerConfig?: Array<Omit<OauthUser["Schema"], "providerConfig">>;
|
|
oauthState$provider$$aggr?: AggregationResult<Omit<OauthState["Schema"], "provider">>;
|
|
oauthUser$providerConfig$$aggr?: AggregationResult<Omit<OauthUser["Schema"], "providerConfig">>;
|
|
};
|
|
Projection: BaseOauthProvider.OpProjection & {
|
|
system?: System["Projection"];
|
|
oauthState$provider?: OakSelection<"select", Omit<OauthState["Projection"], "oauthProvider">, Omit<OauthState["Filter"], "oauthProvider">, OauthState["Sorter"]> & {
|
|
$entity: "oauthState";
|
|
};
|
|
oauthState$provider$$aggr?: DeduceAggregation<Omit<OauthState["Projection"], "oauthProvider">, Omit<OauthState["Filter"], "oauthProvider">, OauthState["Sorter"]> & {
|
|
$entity: "oauthState";
|
|
};
|
|
oauthUser$providerConfig?: OakSelection<"select", Omit<OauthUser["Projection"], "oauthProvider">, Omit<OauthUser["Filter"], "oauthProvider">, OauthUser["Sorter"]> & {
|
|
$entity: "oauthUser";
|
|
};
|
|
oauthUser$providerConfig$$aggr?: DeduceAggregation<Omit<OauthUser["Projection"], "oauthProvider">, Omit<OauthUser["Filter"], "oauthProvider">, OauthUser["Sorter"]> & {
|
|
$entity: "oauthUser";
|
|
};
|
|
};
|
|
FilterUnit: BaseOauthProvider.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
oauthState$provider: MakeFilter<Omit<OauthState["FilterUnit"], "provider">> & SubQueryPredicateMetadata;
|
|
oauthUser$providerConfig: MakeFilter<Omit<OauthUser["FilterUnit"], "providerConfig">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<OauthProvider["FilterUnit"]>;
|
|
SortAttr: Partial<BaseOauthProvider.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: OauthProvider["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: OauthProvider["SortNode"][];
|
|
Selection: OakSelection<"select", OauthProvider["Projection"], OauthProvider["Filter"], OauthProvider["Sorter"]>;
|
|
Aggregation: DeduceAggregation<OauthProvider["Projection"], OauthProvider["Filter"], OauthProvider["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseOauthProvider.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
oauthState$provider?: (OakOperation<"create", Omit<OauthState["CreateOperationData"], "provider"> | Omit<OauthState["CreateOperationData"], "provider">[]> | OakOperation<BaseOauthState.OpUpdateAction, Omit<OauthState["UpdateOperationData"], "provider">, OauthState["Filter"]>)[];
|
|
oauthUser$providerConfig?: (OakOperation<"create", Omit<OauthUser["CreateOperationData"], "providerConfig"> | Omit<OauthUser["CreateOperationData"], "providerConfig">[]> | OakOperation<BaseOauthUser.OpUpdateAction, Omit<OauthUser["UpdateOperationData"], "providerConfig">, OauthUser["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", OauthProvider["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<OauthProvider["CreateOperationData"]>>;
|
|
Create: OauthProvider["CreateSingle"] | OauthProvider["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseOauthProvider.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
oauthState$provider?: (OakOperation<"create", Omit<OauthState["CreateOperationData"], "provider"> | Omit<OauthState["CreateOperationData"], "provider">[]> | OakOperation<BaseOauthState.OpUpdateAction, Omit<OauthState["UpdateOperationData"], "provider">, OauthState["Filter"]> | OakOperation<"remove", OauthState["RemoveOperationData"], OauthState["Filter"]>)[];
|
|
oauthUser$providerConfig?: (OakOperation<"create", Omit<OauthUser["CreateOperationData"], "providerConfig"> | Omit<OauthUser["CreateOperationData"], "providerConfig">[]> | OakOperation<BaseOauthUser.OpUpdateAction, Omit<OauthUser["UpdateOperationData"], "providerConfig">, OauthUser["Filter"]> | OakOperation<"remove", OauthUser["RemoveOperationData"], OauthUser["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseOauthProvider.OpUpdateAction, OauthProvider["UpdateOperationData"], OauthProvider["Filter"], OauthProvider["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", OauthProvider["RemoveOperationData"], OauthProvider["Filter"], OauthProvider["Sorter"]>;
|
|
Operation: OauthProvider["Create"] | OauthProvider["Update"] | OauthProvider["Remove"];
|
|
};
|
|
export type OauthState = {
|
|
OpSchema: BaseOauthState.OpSchema;
|
|
Action: BaseOauthState.OpAction;
|
|
Schema: BaseOauthState.OpSchema & {
|
|
provider: OauthProvider["Schema"];
|
|
user?: User["Schema"];
|
|
oauthUser$state?: Array<Omit<OauthUser["Schema"], "state">>;
|
|
oauthUser$state$$aggr?: AggregationResult<Omit<OauthUser["Schema"], "state">>;
|
|
};
|
|
Projection: BaseOauthState.OpProjection & {
|
|
provider?: OauthProvider["Projection"];
|
|
user?: User["Projection"];
|
|
oauthUser$state?: OakSelection<"select", Omit<OauthUser["Projection"], "oauthState">, Omit<OauthUser["Filter"], "oauthState">, OauthUser["Sorter"]> & {
|
|
$entity: "oauthUser";
|
|
};
|
|
oauthUser$state$$aggr?: DeduceAggregation<Omit<OauthUser["Projection"], "oauthState">, Omit<OauthUser["Filter"], "oauthState">, OauthUser["Sorter"]> & {
|
|
$entity: "oauthUser";
|
|
};
|
|
};
|
|
FilterUnit: BaseOauthState.OpFilter & {
|
|
provider: MakeFilter<OauthProvider["FilterUnit"]>;
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
oauthUser$state: MakeFilter<Omit<OauthUser["FilterUnit"], "state">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<OauthState["FilterUnit"]>;
|
|
SortAttr: Partial<BaseOauthState.OpSortAttr | {
|
|
provider: OauthProvider["SortAttr"];
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: OauthState["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: OauthState["SortNode"][];
|
|
Selection: OakSelection<"select", OauthState["Projection"], OauthState["Filter"], OauthState["Sorter"]>;
|
|
Aggregation: DeduceAggregation<OauthState["Projection"], OauthState["Filter"], OauthState["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseOauthState.OpSchema & {
|
|
provider?: OakOperation<"create", OauthProvider["CreateOperationData"]> | OakOperation<BaseOauthProvider.OpUpdateAction, OauthProvider["UpdateOperationData"], OauthProvider["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
oauthUser$state?: (OakOperation<"create", Omit<OauthUser["CreateOperationData"], "state"> | Omit<OauthUser["CreateOperationData"], "state">[]> | OakOperation<BaseOauthUser.OpUpdateAction, Omit<OauthUser["UpdateOperationData"], "state">, OauthUser["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", OauthState["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<OauthState["CreateOperationData"]>>;
|
|
Create: OauthState["CreateSingle"] | OauthState["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseOauthState.OpSchema & {
|
|
provider?: OakOperation<"create", OauthProvider["CreateOperationData"]> | OakOperation<BaseOauthProvider.OpUpdateAction, OauthProvider["UpdateOperationData"], OauthProvider["Filter"]> | OakOperation<"remove", OauthProvider["RemoveOperationData"], OauthProvider["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
oauthUser$state?: (OakOperation<"create", Omit<OauthUser["CreateOperationData"], "state"> | Omit<OauthUser["CreateOperationData"], "state">[]> | OakOperation<BaseOauthUser.OpUpdateAction, Omit<OauthUser["UpdateOperationData"], "state">, OauthUser["Filter"]> | OakOperation<"remove", OauthUser["RemoveOperationData"], OauthUser["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseOauthState.OpUpdateAction, OauthState["UpdateOperationData"], OauthState["Filter"], OauthState["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", OauthState["RemoveOperationData"], OauthState["Filter"], OauthState["Sorter"]>;
|
|
Operation: OauthState["Create"] | OauthState["Update"] | OauthState["Remove"];
|
|
};
|
|
export type OauthToken = {
|
|
OpSchema: BaseOauthToken.OpSchema;
|
|
Action: BaseOauthToken.OpAction;
|
|
Schema: BaseOauthToken.OpSchema & {
|
|
user: User["Schema"];
|
|
code: OauthAuthorizationCode["Schema"];
|
|
oauthUserAuthorization$token?: Array<Omit<OauthUserAuthorization["Schema"], "token">>;
|
|
oauthUserAuthorization$token$$aggr?: AggregationResult<Omit<OauthUserAuthorization["Schema"], "token">>;
|
|
};
|
|
Projection: BaseOauthToken.OpProjection & {
|
|
user?: User["Projection"];
|
|
code?: OauthAuthorizationCode["Projection"];
|
|
oauthUserAuthorization$token?: OakSelection<"select", Omit<OauthUserAuthorization["Projection"], "oauthToken">, Omit<OauthUserAuthorization["Filter"], "oauthToken">, OauthUserAuthorization["Sorter"]> & {
|
|
$entity: "oauthUserAuthorization";
|
|
};
|
|
oauthUserAuthorization$token$$aggr?: DeduceAggregation<Omit<OauthUserAuthorization["Projection"], "oauthToken">, Omit<OauthUserAuthorization["Filter"], "oauthToken">, OauthUserAuthorization["Sorter"]> & {
|
|
$entity: "oauthUserAuthorization";
|
|
};
|
|
};
|
|
FilterUnit: BaseOauthToken.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
code: MakeFilter<OauthAuthorizationCode["FilterUnit"]>;
|
|
oauthUserAuthorization$token: MakeFilter<Omit<OauthUserAuthorization["FilterUnit"], "token">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<OauthToken["FilterUnit"]>;
|
|
SortAttr: Partial<BaseOauthToken.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
code: OauthAuthorizationCode["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: OauthToken["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: OauthToken["SortNode"][];
|
|
Selection: OakSelection<"select", OauthToken["Projection"], OauthToken["Filter"], OauthToken["Sorter"]>;
|
|
Aggregation: DeduceAggregation<OauthToken["Projection"], OauthToken["Filter"], OauthToken["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseOauthToken.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
code?: OakOperation<"create", OauthAuthorizationCode["CreateOperationData"]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, OauthAuthorizationCode["UpdateOperationData"], OauthAuthorizationCode["Filter"]>;
|
|
oauthUserAuthorization$token?: (OakOperation<"create", Omit<OauthUserAuthorization["CreateOperationData"], "token"> | Omit<OauthUserAuthorization["CreateOperationData"], "token">[]> | OakOperation<BaseOauthUserAuthorization.OpUpdateAction, Omit<OauthUserAuthorization["UpdateOperationData"], "token">, OauthUserAuthorization["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", OauthToken["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<OauthToken["CreateOperationData"]>>;
|
|
Create: OauthToken["CreateSingle"] | OauthToken["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseOauthToken.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
code?: OakOperation<"create", OauthAuthorizationCode["CreateOperationData"]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, OauthAuthorizationCode["UpdateOperationData"], OauthAuthorizationCode["Filter"]> | OakOperation<"remove", OauthAuthorizationCode["RemoveOperationData"], OauthAuthorizationCode["Filter"]>;
|
|
oauthUserAuthorization$token?: (OakOperation<"create", Omit<OauthUserAuthorization["CreateOperationData"], "token"> | Omit<OauthUserAuthorization["CreateOperationData"], "token">[]> | OakOperation<BaseOauthUserAuthorization.OpUpdateAction, Omit<OauthUserAuthorization["UpdateOperationData"], "token">, OauthUserAuthorization["Filter"]> | OakOperation<"remove", OauthUserAuthorization["RemoveOperationData"], OauthUserAuthorization["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseOauthToken.OpUpdateAction, OauthToken["UpdateOperationData"], OauthToken["Filter"], OauthToken["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", OauthToken["RemoveOperationData"], OauthToken["Filter"], OauthToken["Sorter"]>;
|
|
Operation: OauthToken["Create"] | OauthToken["Update"] | OauthToken["Remove"];
|
|
};
|
|
export type OauthUser = {
|
|
OpSchema: BaseOauthUser.OpSchema;
|
|
Action: BaseOauthUser.OpAction;
|
|
Schema: BaseOauthUser.OpSchema & {
|
|
user?: User["Schema"];
|
|
application: Application["Schema"];
|
|
providerConfig: OauthProvider["Schema"];
|
|
state: OauthState["Schema"];
|
|
token$entity?: Array<Omit<Token["Schema"], "entity">>;
|
|
token$entity$$aggr?: AggregationResult<Omit<Token["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseOauthUser.OpProjection & {
|
|
user?: User["Projection"];
|
|
application?: Application["Projection"];
|
|
providerConfig?: OauthProvider["Projection"];
|
|
state?: OauthState["Projection"];
|
|
token$entity?: OakSelection<"select", Omit<Token["Projection"], "oauthUser">, Omit<Token["Filter"], "oauthUser">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$entity$$aggr?: DeduceAggregation<Omit<Token["Projection"], "oauthUser">, Omit<Token["Filter"], "oauthUser">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
};
|
|
FilterUnit: BaseOauthUser.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
providerConfig: MakeFilter<OauthProvider["FilterUnit"]>;
|
|
state: MakeFilter<OauthState["FilterUnit"]>;
|
|
token$entity: MakeFilter<Omit<Token["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<OauthUser["FilterUnit"]>;
|
|
SortAttr: Partial<BaseOauthUser.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
application: Application["SortAttr"];
|
|
providerConfig: OauthProvider["SortAttr"];
|
|
state: OauthState["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: OauthUser["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: OauthUser["SortNode"][];
|
|
Selection: OakSelection<"select", OauthUser["Projection"], OauthUser["Filter"], OauthUser["Sorter"]>;
|
|
Aggregation: DeduceAggregation<OauthUser["Projection"], OauthUser["Filter"], OauthUser["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseOauthUser.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
providerConfig?: OakOperation<"create", OauthProvider["CreateOperationData"]> | OakOperation<BaseOauthProvider.OpUpdateAction, OauthProvider["UpdateOperationData"], OauthProvider["Filter"]>;
|
|
state?: OakOperation<"create", OauthState["CreateOperationData"]> | OakOperation<BaseOauthState.OpUpdateAction, OauthState["UpdateOperationData"], OauthState["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "oauthUser"> | Omit<Token["CreateOperationData"], "oauthUser">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "oauthUser">, Token["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", OauthUser["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<OauthUser["CreateOperationData"]>>;
|
|
Create: OauthUser["CreateSingle"] | OauthUser["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseOauthUser.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
providerConfig?: OakOperation<"create", OauthProvider["CreateOperationData"]> | OakOperation<BaseOauthProvider.OpUpdateAction, OauthProvider["UpdateOperationData"], OauthProvider["Filter"]> | OakOperation<"remove", OauthProvider["RemoveOperationData"], OauthProvider["Filter"]>;
|
|
state?: OakOperation<"create", OauthState["CreateOperationData"]> | OakOperation<BaseOauthState.OpUpdateAction, OauthState["UpdateOperationData"], OauthState["Filter"]> | OakOperation<"remove", OauthState["RemoveOperationData"], OauthState["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "oauthUser"> | Omit<Token["CreateOperationData"], "oauthUser">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "oauthUser">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseOauthUser.OpUpdateAction, OauthUser["UpdateOperationData"], OauthUser["Filter"], OauthUser["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", OauthUser["RemoveOperationData"], OauthUser["Filter"], OauthUser["Sorter"]>;
|
|
Operation: OauthUser["Create"] | OauthUser["Update"] | OauthUser["Remove"];
|
|
};
|
|
export type OauthUserAuthorization = {
|
|
OpSchema: BaseOauthUserAuthorization.OpSchema;
|
|
Action: BaseOauthUserAuthorization.OpAction;
|
|
Schema: BaseOauthUserAuthorization.OpSchema & {
|
|
user: User["Schema"];
|
|
application: OauthApplication["Schema"];
|
|
code?: OauthAuthorizationCode["Schema"];
|
|
token?: OauthToken["Schema"];
|
|
};
|
|
Projection: BaseOauthUserAuthorization.OpProjection & {
|
|
user?: User["Projection"];
|
|
application?: OauthApplication["Projection"];
|
|
code?: OauthAuthorizationCode["Projection"];
|
|
token?: OauthToken["Projection"];
|
|
};
|
|
FilterUnit: BaseOauthUserAuthorization.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
application: MakeFilter<OauthApplication["FilterUnit"]>;
|
|
code: MakeFilter<OauthAuthorizationCode["FilterUnit"]>;
|
|
token: MakeFilter<OauthToken["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<OauthUserAuthorization["FilterUnit"]>;
|
|
SortAttr: Partial<BaseOauthUserAuthorization.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
application: OauthApplication["SortAttr"];
|
|
code: OauthAuthorizationCode["SortAttr"];
|
|
token: OauthToken["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: OauthUserAuthorization["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: OauthUserAuthorization["SortNode"][];
|
|
Selection: OakSelection<"select", OauthUserAuthorization["Projection"], OauthUserAuthorization["Filter"], OauthUserAuthorization["Sorter"]>;
|
|
Aggregation: DeduceAggregation<OauthUserAuthorization["Projection"], OauthUserAuthorization["Filter"], OauthUserAuthorization["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseOauthUserAuthorization.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
application?: OakOperation<"create", OauthApplication["CreateOperationData"]> | OakOperation<BaseOauthApplication.OpUpdateAction, OauthApplication["UpdateOperationData"], OauthApplication["Filter"]>;
|
|
code?: OakOperation<"create", OauthAuthorizationCode["CreateOperationData"]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, OauthAuthorizationCode["UpdateOperationData"], OauthAuthorizationCode["Filter"]>;
|
|
token?: OakOperation<"create", OauthToken["CreateOperationData"]> | OakOperation<BaseOauthToken.OpUpdateAction, OauthToken["UpdateOperationData"], OauthToken["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", OauthUserAuthorization["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<OauthUserAuthorization["CreateOperationData"]>>;
|
|
Create: OauthUserAuthorization["CreateSingle"] | OauthUserAuthorization["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseOauthUserAuthorization.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
application?: OakOperation<"create", OauthApplication["CreateOperationData"]> | OakOperation<BaseOauthApplication.OpUpdateAction, OauthApplication["UpdateOperationData"], OauthApplication["Filter"]> | OakOperation<"remove", OauthApplication["RemoveOperationData"], OauthApplication["Filter"]>;
|
|
code?: OakOperation<"create", OauthAuthorizationCode["CreateOperationData"]> | OakOperation<BaseOauthAuthorizationCode.OpUpdateAction, OauthAuthorizationCode["UpdateOperationData"], OauthAuthorizationCode["Filter"]> | OakOperation<"remove", OauthAuthorizationCode["RemoveOperationData"], OauthAuthorizationCode["Filter"]>;
|
|
token?: OakOperation<"create", OauthToken["CreateOperationData"]> | OakOperation<BaseOauthToken.OpUpdateAction, OauthToken["UpdateOperationData"], OauthToken["Filter"]> | OakOperation<"remove", OauthToken["RemoveOperationData"], OauthToken["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseOauthUserAuthorization.OpUpdateAction, OauthUserAuthorization["UpdateOperationData"], OauthUserAuthorization["Filter"], OauthUserAuthorization["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", OauthUserAuthorization["RemoveOperationData"], OauthUserAuthorization["Filter"], OauthUserAuthorization["Sorter"]>;
|
|
Operation: OauthUserAuthorization["Create"] | OauthUserAuthorization["Update"] | OauthUserAuthorization["Remove"];
|
|
};
|
|
export type Parasite = {
|
|
OpSchema: BaseParasite.OpSchema;
|
|
Action: BaseParasite.OpAction;
|
|
Schema: BaseParasite.OpSchema & {
|
|
user: User["Schema"];
|
|
token$entity?: Array<Omit<Token["Schema"], "entity">>;
|
|
token$entity$$aggr?: AggregationResult<Omit<Token["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseParasite.OpProjection & {
|
|
user?: User["Projection"];
|
|
token$entity?: OakSelection<"select", Omit<Token["Projection"], "parasite">, Omit<Token["Filter"], "parasite">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$entity$$aggr?: DeduceAggregation<Omit<Token["Projection"], "parasite">, Omit<Token["Filter"], "parasite">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
};
|
|
FilterUnit: BaseParasite.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
token$entity: MakeFilter<Omit<Token["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Parasite["FilterUnit"]>;
|
|
SortAttr: Partial<BaseParasite.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Parasite["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Parasite["SortNode"][];
|
|
Selection: OakSelection<"select", Parasite["Projection"], Parasite["Filter"], Parasite["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Parasite["Projection"], Parasite["Filter"], Parasite["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseParasite.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "parasite"> | Omit<Token["CreateOperationData"], "parasite">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "parasite">, Token["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Parasite["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Parasite["CreateOperationData"]>>;
|
|
Create: Parasite["CreateSingle"] | Parasite["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseParasite.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "parasite"> | Omit<Token["CreateOperationData"], "parasite">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "parasite">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseParasite.OpUpdateAction, Parasite["UpdateOperationData"], Parasite["Filter"], Parasite["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Parasite["RemoveOperationData"], Parasite["Filter"], Parasite["Sorter"]>;
|
|
Operation: Parasite["Create"] | Parasite["Update"] | Parasite["Remove"];
|
|
};
|
|
export type Passport = {
|
|
OpSchema: BasePassport.OpSchema;
|
|
Action: BasePassport.OpAction;
|
|
Schema: BasePassport.OpSchema & {
|
|
system: System["Schema"];
|
|
applicationPassport$passport?: Array<Omit<ApplicationPassport["Schema"], "passport">>;
|
|
applicationPassport$passport$$aggr?: AggregationResult<Omit<ApplicationPassport["Schema"], "passport">>;
|
|
};
|
|
Projection: BasePassport.OpProjection & {
|
|
system?: System["Projection"];
|
|
applicationPassport$passport?: OakSelection<"select", Omit<ApplicationPassport["Projection"], "passport">, Omit<ApplicationPassport["Filter"], "passport">, ApplicationPassport["Sorter"]> & {
|
|
$entity: "applicationPassport";
|
|
};
|
|
applicationPassport$passport$$aggr?: DeduceAggregation<Omit<ApplicationPassport["Projection"], "passport">, Omit<ApplicationPassport["Filter"], "passport">, ApplicationPassport["Sorter"]> & {
|
|
$entity: "applicationPassport";
|
|
};
|
|
};
|
|
FilterUnit: BasePassport.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
applicationPassport$passport: MakeFilter<Omit<ApplicationPassport["FilterUnit"], "passport">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Passport["FilterUnit"]>;
|
|
SortAttr: Partial<BasePassport.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Passport["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Passport["SortNode"][];
|
|
Selection: OakSelection<"select", Passport["Projection"], Passport["Filter"], Passport["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Passport["Projection"], Passport["Filter"], Passport["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BasePassport.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
applicationPassport$passport?: (OakOperation<"create", Omit<ApplicationPassport["CreateOperationData"], "passport"> | Omit<ApplicationPassport["CreateOperationData"], "passport">[]> | OakOperation<BaseApplicationPassport.OpUpdateAction, Omit<ApplicationPassport["UpdateOperationData"], "passport">, ApplicationPassport["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Passport["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Passport["CreateOperationData"]>>;
|
|
Create: Passport["CreateSingle"] | Passport["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BasePassport.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
applicationPassport$passport?: (OakOperation<"create", Omit<ApplicationPassport["CreateOperationData"], "passport"> | Omit<ApplicationPassport["CreateOperationData"], "passport">[]> | OakOperation<BaseApplicationPassport.OpUpdateAction, Omit<ApplicationPassport["UpdateOperationData"], "passport">, ApplicationPassport["Filter"]> | OakOperation<"remove", ApplicationPassport["RemoveOperationData"], ApplicationPassport["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BasePassport.OpUpdateAction, Passport["UpdateOperationData"], Passport["Filter"], Passport["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Passport["RemoveOperationData"], Passport["Filter"], Passport["Sorter"]>;
|
|
Operation: Passport["Create"] | Passport["Update"] | Passport["Remove"];
|
|
};
|
|
export type Platform = {
|
|
OpSchema: BasePlatform.OpSchema;
|
|
Action: BasePlatform.OpAction;
|
|
Schema: BasePlatform.OpSchema & {
|
|
message$platform?: Array<Omit<Message["Schema"], "platform">>;
|
|
system$platform?: Array<Omit<System["Schema"], "platform">>;
|
|
relation$entity?: Array<Omit<Relation["Schema"], "entity">>;
|
|
userRelation$entity?: Array<Omit<UserRelation["Schema"], "entity">>;
|
|
message$platform$$aggr?: AggregationResult<Omit<Message["Schema"], "platform">>;
|
|
system$platform$$aggr?: AggregationResult<Omit<System["Schema"], "platform">>;
|
|
relation$entity$$aggr?: AggregationResult<Omit<Relation["Schema"], "entity">>;
|
|
userRelation$entity$$aggr?: AggregationResult<Omit<UserRelation["Schema"], "entity">>;
|
|
};
|
|
Projection: BasePlatform.OpProjection & {
|
|
message$platform?: OakSelection<"select", Omit<Message["Projection"], "platform">, Omit<Message["Filter"], "platform">, Message["Sorter"]> & {
|
|
$entity: "message";
|
|
};
|
|
message$platform$$aggr?: DeduceAggregation<Omit<Message["Projection"], "platform">, Omit<Message["Filter"], "platform">, Message["Sorter"]> & {
|
|
$entity: "message";
|
|
};
|
|
system$platform?: OakSelection<"select", Omit<System["Projection"], "platform">, Omit<System["Filter"], "platform">, System["Sorter"]> & {
|
|
$entity: "system";
|
|
};
|
|
system$platform$$aggr?: DeduceAggregation<Omit<System["Projection"], "platform">, Omit<System["Filter"], "platform">, System["Sorter"]> & {
|
|
$entity: "system";
|
|
};
|
|
relation$entity?: OakSelection<"select", Omit<Relation["Projection"], "platform">, Omit<Relation["Filter"], "platform">, Relation["Sorter"]> & {
|
|
$entity: "relation";
|
|
};
|
|
relation$entity$$aggr?: DeduceAggregation<Omit<Relation["Projection"], "platform">, Omit<Relation["Filter"], "platform">, Relation["Sorter"]> & {
|
|
$entity: "relation";
|
|
};
|
|
userRelation$entity?: OakSelection<"select", Omit<UserRelation["Projection"], "platform">, Omit<UserRelation["Filter"], "platform">, UserRelation["Sorter"]> & {
|
|
$entity: "userRelation";
|
|
};
|
|
userRelation$entity$$aggr?: DeduceAggregation<Omit<UserRelation["Projection"], "platform">, Omit<UserRelation["Filter"], "platform">, UserRelation["Sorter"]> & {
|
|
$entity: "userRelation";
|
|
};
|
|
};
|
|
FilterUnit: BasePlatform.OpFilter & {
|
|
message$platform: MakeFilter<Omit<Message["FilterUnit"], "platform">> & SubQueryPredicateMetadata;
|
|
system$platform: MakeFilter<Omit<System["FilterUnit"], "platform">> & SubQueryPredicateMetadata;
|
|
relation$entity: MakeFilter<Omit<Relation["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
userRelation$entity: MakeFilter<Omit<UserRelation["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Platform["FilterUnit"]>;
|
|
SortAttr: Partial<BasePlatform.OpSortAttr | {}>;
|
|
SortNode: {
|
|
$attr: Platform["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Platform["SortNode"][];
|
|
Selection: OakSelection<"select", Platform["Projection"], Platform["Filter"], Platform["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Platform["Projection"], Platform["Filter"], Platform["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BasePlatform.OpSchema & {
|
|
message$platform?: (OakOperation<"create", Omit<Message["CreateOperationData"], "platform"> | Omit<Message["CreateOperationData"], "platform">[]> | OakOperation<BaseMessage.OpUpdateAction, Omit<Message["UpdateOperationData"], "platform">, Message["Filter"]>)[];
|
|
system$platform?: (OakOperation<"create", Omit<System["CreateOperationData"], "platform"> | Omit<System["CreateOperationData"], "platform">[]> | OakOperation<BaseSystem.OpUpdateAction, Omit<System["UpdateOperationData"], "platform">, System["Filter"]>)[];
|
|
relation$entity?: (OakOperation<"create", Omit<Relation["CreateOperationData"], "platform"> | Omit<Relation["CreateOperationData"], "platform">[]> | OakOperation<BaseRelation.OpUpdateAction, Omit<Relation["UpdateOperationData"], "platform">, Relation["Filter"]>)[];
|
|
userRelation$entity?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "platform"> | Omit<UserRelation["CreateOperationData"], "platform">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "platform">, UserRelation["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Platform["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Platform["CreateOperationData"]>>;
|
|
Create: Platform["CreateSingle"] | Platform["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BasePlatform.OpSchema & {
|
|
message$platform?: (OakOperation<"create", Omit<Message["CreateOperationData"], "platform"> | Omit<Message["CreateOperationData"], "platform">[]> | OakOperation<BaseMessage.OpUpdateAction, Omit<Message["UpdateOperationData"], "platform">, Message["Filter"]> | OakOperation<"remove", Message["RemoveOperationData"], Message["Filter"]>)[];
|
|
system$platform?: (OakOperation<"create", Omit<System["CreateOperationData"], "platform"> | Omit<System["CreateOperationData"], "platform">[]> | OakOperation<BaseSystem.OpUpdateAction, Omit<System["UpdateOperationData"], "platform">, System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>)[];
|
|
relation$entity?: (OakOperation<"create", Omit<Relation["CreateOperationData"], "platform"> | Omit<Relation["CreateOperationData"], "platform">[]> | OakOperation<BaseRelation.OpUpdateAction, Omit<Relation["UpdateOperationData"], "platform">, Relation["Filter"]> | OakOperation<"remove", Relation["RemoveOperationData"], Relation["Filter"]>)[];
|
|
userRelation$entity?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "platform"> | Omit<UserRelation["CreateOperationData"], "platform">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "platform">, UserRelation["Filter"]> | OakOperation<"remove", UserRelation["RemoveOperationData"], UserRelation["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BasePlatform.OpUpdateAction, Platform["UpdateOperationData"], Platform["Filter"], Platform["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Platform["RemoveOperationData"], Platform["Filter"], Platform["Sorter"]>;
|
|
Operation: Platform["Create"] | Platform["Update"] | Platform["Remove"];
|
|
};
|
|
export type ReadRemark = {
|
|
OpSchema: BaseReadRemark.OpSchema;
|
|
Action: BaseReadRemark.OpAction;
|
|
Schema: BaseReadRemark.OpSchema & {
|
|
user: User["Schema"];
|
|
session: Session["Schema"];
|
|
};
|
|
Projection: BaseReadRemark.OpProjection & {
|
|
user?: User["Projection"];
|
|
session?: Session["Projection"];
|
|
};
|
|
FilterUnit: BaseReadRemark.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
session: MakeFilter<Session["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<ReadRemark["FilterUnit"]>;
|
|
SortAttr: Partial<BaseReadRemark.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
session: Session["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ReadRemark["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ReadRemark["SortNode"][];
|
|
Selection: OakSelection<"select", ReadRemark["Projection"], ReadRemark["Filter"], ReadRemark["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ReadRemark["Projection"], ReadRemark["Filter"], ReadRemark["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseReadRemark.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
session?: OakOperation<"create", Session["CreateOperationData"]> | OakOperation<BaseSession.OpUpdateAction, Session["UpdateOperationData"], Session["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ReadRemark["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ReadRemark["CreateOperationData"]>>;
|
|
Create: ReadRemark["CreateSingle"] | ReadRemark["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseReadRemark.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
session?: OakOperation<"create", Session["CreateOperationData"]> | OakOperation<BaseSession.OpUpdateAction, Session["UpdateOperationData"], Session["Filter"]> | OakOperation<"remove", Session["RemoveOperationData"], Session["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseReadRemark.OpUpdateAction, ReadRemark["UpdateOperationData"], ReadRemark["Filter"], ReadRemark["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ReadRemark["RemoveOperationData"], ReadRemark["Filter"], ReadRemark["Sorter"]>;
|
|
Operation: ReadRemark["Create"] | ReadRemark["Update"] | ReadRemark["Remove"];
|
|
};
|
|
export type Session = {
|
|
OpSchema: BaseSession.OpSchema;
|
|
Action: BaseSession.OpAction;
|
|
Schema: BaseSession.OpSchema & {
|
|
user?: User["Schema"];
|
|
application?: Application["Schema"];
|
|
readRemark$session?: Array<Omit<ReadRemark["Schema"], "session">>;
|
|
sessionMessage$session?: Array<Omit<SessionMessage["Schema"], "session">>;
|
|
relation$entity?: Array<Omit<Relation["Schema"], "entity">>;
|
|
userRelation$entity?: Array<Omit<UserRelation["Schema"], "entity">>;
|
|
readRemark$session$$aggr?: AggregationResult<Omit<ReadRemark["Schema"], "session">>;
|
|
sessionMessage$session$$aggr?: AggregationResult<Omit<SessionMessage["Schema"], "session">>;
|
|
relation$entity$$aggr?: AggregationResult<Omit<Relation["Schema"], "entity">>;
|
|
userRelation$entity$$aggr?: AggregationResult<Omit<UserRelation["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseSession.OpProjection & {
|
|
user?: User["Projection"];
|
|
application?: Application["Projection"];
|
|
readRemark$session?: OakSelection<"select", Omit<ReadRemark["Projection"], "session">, Omit<ReadRemark["Filter"], "session">, ReadRemark["Sorter"]> & {
|
|
$entity: "readRemark";
|
|
};
|
|
readRemark$session$$aggr?: DeduceAggregation<Omit<ReadRemark["Projection"], "session">, Omit<ReadRemark["Filter"], "session">, ReadRemark["Sorter"]> & {
|
|
$entity: "readRemark";
|
|
};
|
|
sessionMessage$session?: OakSelection<"select", Omit<SessionMessage["Projection"], "session">, Omit<SessionMessage["Filter"], "session">, SessionMessage["Sorter"]> & {
|
|
$entity: "sessionMessage";
|
|
};
|
|
sessionMessage$session$$aggr?: DeduceAggregation<Omit<SessionMessage["Projection"], "session">, Omit<SessionMessage["Filter"], "session">, SessionMessage["Sorter"]> & {
|
|
$entity: "sessionMessage";
|
|
};
|
|
relation$entity?: OakSelection<"select", Omit<Relation["Projection"], "session">, Omit<Relation["Filter"], "session">, Relation["Sorter"]> & {
|
|
$entity: "relation";
|
|
};
|
|
relation$entity$$aggr?: DeduceAggregation<Omit<Relation["Projection"], "session">, Omit<Relation["Filter"], "session">, Relation["Sorter"]> & {
|
|
$entity: "relation";
|
|
};
|
|
userRelation$entity?: OakSelection<"select", Omit<UserRelation["Projection"], "session">, Omit<UserRelation["Filter"], "session">, UserRelation["Sorter"]> & {
|
|
$entity: "userRelation";
|
|
};
|
|
userRelation$entity$$aggr?: DeduceAggregation<Omit<UserRelation["Projection"], "session">, Omit<UserRelation["Filter"], "session">, UserRelation["Sorter"]> & {
|
|
$entity: "userRelation";
|
|
};
|
|
};
|
|
FilterUnit: BaseSession.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
readRemark$session: MakeFilter<Omit<ReadRemark["FilterUnit"], "session">> & SubQueryPredicateMetadata;
|
|
sessionMessage$session: MakeFilter<Omit<SessionMessage["FilterUnit"], "session">> & SubQueryPredicateMetadata;
|
|
relation$entity: MakeFilter<Omit<Relation["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
userRelation$entity: MakeFilter<Omit<UserRelation["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Session["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSession.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
application: Application["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Session["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Session["SortNode"][];
|
|
Selection: OakSelection<"select", Session["Projection"], Session["Filter"], Session["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Session["Projection"], Session["Filter"], Session["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSession.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
readRemark$session?: (OakOperation<"create", Omit<ReadRemark["CreateOperationData"], "session"> | Omit<ReadRemark["CreateOperationData"], "session">[]> | OakOperation<BaseReadRemark.OpUpdateAction, Omit<ReadRemark["UpdateOperationData"], "session">, ReadRemark["Filter"]>)[];
|
|
sessionMessage$session?: (OakOperation<"create", Omit<SessionMessage["CreateOperationData"], "session"> | Omit<SessionMessage["CreateOperationData"], "session">[]> | OakOperation<BaseSessionMessage.OpUpdateAction, Omit<SessionMessage["UpdateOperationData"], "session">, SessionMessage["Filter"]>)[];
|
|
relation$entity?: (OakOperation<"create", Omit<Relation["CreateOperationData"], "session"> | Omit<Relation["CreateOperationData"], "session">[]> | OakOperation<BaseRelation.OpUpdateAction, Omit<Relation["UpdateOperationData"], "session">, Relation["Filter"]>)[];
|
|
userRelation$entity?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "session"> | Omit<UserRelation["CreateOperationData"], "session">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "session">, UserRelation["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Session["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Session["CreateOperationData"]>>;
|
|
Create: Session["CreateSingle"] | Session["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSession.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
readRemark$session?: (OakOperation<"create", Omit<ReadRemark["CreateOperationData"], "session"> | Omit<ReadRemark["CreateOperationData"], "session">[]> | OakOperation<BaseReadRemark.OpUpdateAction, Omit<ReadRemark["UpdateOperationData"], "session">, ReadRemark["Filter"]> | OakOperation<"remove", ReadRemark["RemoveOperationData"], ReadRemark["Filter"]>)[];
|
|
sessionMessage$session?: (OakOperation<"create", Omit<SessionMessage["CreateOperationData"], "session"> | Omit<SessionMessage["CreateOperationData"], "session">[]> | OakOperation<BaseSessionMessage.OpUpdateAction, Omit<SessionMessage["UpdateOperationData"], "session">, SessionMessage["Filter"]> | OakOperation<"remove", SessionMessage["RemoveOperationData"], SessionMessage["Filter"]>)[];
|
|
relation$entity?: (OakOperation<"create", Omit<Relation["CreateOperationData"], "session"> | Omit<Relation["CreateOperationData"], "session">[]> | OakOperation<BaseRelation.OpUpdateAction, Omit<Relation["UpdateOperationData"], "session">, Relation["Filter"]> | OakOperation<"remove", Relation["RemoveOperationData"], Relation["Filter"]>)[];
|
|
userRelation$entity?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "session"> | Omit<UserRelation["CreateOperationData"], "session">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "session">, UserRelation["Filter"]> | OakOperation<"remove", UserRelation["RemoveOperationData"], UserRelation["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseSession.OpUpdateAction, Session["UpdateOperationData"], Session["Filter"], Session["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Session["RemoveOperationData"], Session["Filter"], Session["Sorter"]>;
|
|
Operation: Session["Create"] | Session["Update"] | Session["Remove"];
|
|
};
|
|
export type SessionMessage = {
|
|
OpSchema: BaseSessionMessage.OpSchema;
|
|
Action: BaseSessionMessage.OpAction;
|
|
Schema: BaseSessionMessage.OpSchema & {
|
|
application: Application["Schema"];
|
|
session: Session["Schema"];
|
|
user?: User["Schema"];
|
|
wechatUser?: WechatUser["Schema"];
|
|
extraFile$entity?: Array<Omit<ExtraFile["Schema"], "entity">>;
|
|
extraFile$entity$$aggr?: AggregationResult<Omit<ExtraFile["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseSessionMessage.OpProjection & {
|
|
application?: Application["Projection"];
|
|
session?: Session["Projection"];
|
|
user?: User["Projection"];
|
|
wechatUser?: WechatUser["Projection"];
|
|
extraFile$entity?: OakSelection<"select", Omit<ExtraFile["Projection"], "sessionMessage">, Omit<ExtraFile["Filter"], "sessionMessage">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
extraFile$entity$$aggr?: DeduceAggregation<Omit<ExtraFile["Projection"], "sessionMessage">, Omit<ExtraFile["Filter"], "sessionMessage">, ExtraFile["Sorter"]> & {
|
|
$entity: "extraFile";
|
|
};
|
|
};
|
|
FilterUnit: BaseSessionMessage.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
session: MakeFilter<Session["FilterUnit"]>;
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
wechatUser: MakeFilter<WechatUser["FilterUnit"]>;
|
|
extraFile$entity: MakeFilter<Omit<ExtraFile["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<SessionMessage["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSessionMessage.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
session: Session["SortAttr"];
|
|
user: User["SortAttr"];
|
|
wechatUser: WechatUser["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: SessionMessage["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: SessionMessage["SortNode"][];
|
|
Selection: OakSelection<"select", SessionMessage["Projection"], SessionMessage["Filter"], SessionMessage["Sorter"]>;
|
|
Aggregation: DeduceAggregation<SessionMessage["Projection"], SessionMessage["Filter"], SessionMessage["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSessionMessage.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
session?: OakOperation<"create", Session["CreateOperationData"]> | OakOperation<BaseSession.OpUpdateAction, Session["UpdateOperationData"], Session["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
wechatUser?: OakOperation<"create", WechatUser["CreateOperationData"]> | OakOperation<BaseWechatUser.OpUpdateAction, WechatUser["UpdateOperationData"], WechatUser["Filter"]>;
|
|
extraFile$entity?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "sessionMessage"> | Omit<ExtraFile["CreateOperationData"], "sessionMessage">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "sessionMessage">, ExtraFile["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", SessionMessage["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<SessionMessage["CreateOperationData"]>>;
|
|
Create: SessionMessage["CreateSingle"] | SessionMessage["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSessionMessage.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
session?: OakOperation<"create", Session["CreateOperationData"]> | OakOperation<BaseSession.OpUpdateAction, Session["UpdateOperationData"], Session["Filter"]> | OakOperation<"remove", Session["RemoveOperationData"], Session["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
wechatUser?: OakOperation<"create", WechatUser["CreateOperationData"]> | OakOperation<BaseWechatUser.OpUpdateAction, WechatUser["UpdateOperationData"], WechatUser["Filter"]> | OakOperation<"remove", WechatUser["RemoveOperationData"], WechatUser["Filter"]>;
|
|
extraFile$entity?: (OakOperation<"create", Omit<ExtraFile["CreateOperationData"], "sessionMessage"> | Omit<ExtraFile["CreateOperationData"], "sessionMessage">[]> | OakOperation<BaseExtraFile.OpUpdateAction, Omit<ExtraFile["UpdateOperationData"], "sessionMessage">, ExtraFile["Filter"]> | OakOperation<"remove", ExtraFile["RemoveOperationData"], ExtraFile["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseSessionMessage.OpUpdateAction, SessionMessage["UpdateOperationData"], SessionMessage["Filter"], SessionMessage["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", SessionMessage["RemoveOperationData"], SessionMessage["Filter"], SessionMessage["Sorter"]>;
|
|
Operation: SessionMessage["Create"] | SessionMessage["Update"] | SessionMessage["Remove"];
|
|
};
|
|
export type SmsTemplate = {
|
|
OpSchema: BaseSmsTemplate.OpSchema;
|
|
Action: BaseSmsTemplate.OpAction;
|
|
Schema: BaseSmsTemplate.OpSchema & {
|
|
system: System["Schema"];
|
|
messageTypeSmsTemplate$template?: Array<Omit<MessageTypeSmsTemplate["Schema"], "template">>;
|
|
messageTypeSmsTemplate$template$$aggr?: AggregationResult<Omit<MessageTypeSmsTemplate["Schema"], "template">>;
|
|
};
|
|
Projection: BaseSmsTemplate.OpProjection & {
|
|
system?: System["Projection"];
|
|
messageTypeSmsTemplate$template?: OakSelection<"select", Omit<MessageTypeSmsTemplate["Projection"], "smsTemplate">, Omit<MessageTypeSmsTemplate["Filter"], "smsTemplate">, MessageTypeSmsTemplate["Sorter"]> & {
|
|
$entity: "messageTypeSmsTemplate";
|
|
};
|
|
messageTypeSmsTemplate$template$$aggr?: DeduceAggregation<Omit<MessageTypeSmsTemplate["Projection"], "smsTemplate">, Omit<MessageTypeSmsTemplate["Filter"], "smsTemplate">, MessageTypeSmsTemplate["Sorter"]> & {
|
|
$entity: "messageTypeSmsTemplate";
|
|
};
|
|
};
|
|
FilterUnit: BaseSmsTemplate.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
messageTypeSmsTemplate$template: MakeFilter<Omit<MessageTypeSmsTemplate["FilterUnit"], "template">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<SmsTemplate["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSmsTemplate.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: SmsTemplate["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: SmsTemplate["SortNode"][];
|
|
Selection: OakSelection<"select", SmsTemplate["Projection"], SmsTemplate["Filter"], SmsTemplate["Sorter"]>;
|
|
Aggregation: DeduceAggregation<SmsTemplate["Projection"], SmsTemplate["Filter"], SmsTemplate["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSmsTemplate.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
messageTypeSmsTemplate$template?: (OakOperation<"create", Omit<MessageTypeSmsTemplate["CreateOperationData"], "template"> | Omit<MessageTypeSmsTemplate["CreateOperationData"], "template">[]> | OakOperation<BaseMessageTypeSmsTemplate.OpUpdateAction, Omit<MessageTypeSmsTemplate["UpdateOperationData"], "template">, MessageTypeSmsTemplate["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", SmsTemplate["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<SmsTemplate["CreateOperationData"]>>;
|
|
Create: SmsTemplate["CreateSingle"] | SmsTemplate["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSmsTemplate.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
messageTypeSmsTemplate$template?: (OakOperation<"create", Omit<MessageTypeSmsTemplate["CreateOperationData"], "template"> | Omit<MessageTypeSmsTemplate["CreateOperationData"], "template">[]> | OakOperation<BaseMessageTypeSmsTemplate.OpUpdateAction, Omit<MessageTypeSmsTemplate["UpdateOperationData"], "template">, MessageTypeSmsTemplate["Filter"]> | OakOperation<"remove", MessageTypeSmsTemplate["RemoveOperationData"], MessageTypeSmsTemplate["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseSmsTemplate.OpUpdateAction, SmsTemplate["UpdateOperationData"], SmsTemplate["Filter"], SmsTemplate["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", SmsTemplate["RemoveOperationData"], SmsTemplate["Filter"], SmsTemplate["Sorter"]>;
|
|
Operation: SmsTemplate["Create"] | SmsTemplate["Update"] | SmsTemplate["Remove"];
|
|
};
|
|
export type Station = {
|
|
OpSchema: BaseStation.OpSchema;
|
|
Action: BaseStation.OpAction;
|
|
Schema: BaseStation.OpSchema & {
|
|
area: Area["Schema"];
|
|
subwayStation$station?: Array<Omit<SubwayStation["Schema"], "station">>;
|
|
subwayStation$station$$aggr?: AggregationResult<Omit<SubwayStation["Schema"], "station">>;
|
|
};
|
|
Projection: BaseStation.OpProjection & {
|
|
area?: Area["Projection"];
|
|
subwayStation$station?: OakSelection<"select", Omit<SubwayStation["Projection"], "station">, Omit<SubwayStation["Filter"], "station">, SubwayStation["Sorter"]> & {
|
|
$entity: "subwayStation";
|
|
};
|
|
subwayStation$station$$aggr?: DeduceAggregation<Omit<SubwayStation["Projection"], "station">, Omit<SubwayStation["Filter"], "station">, SubwayStation["Sorter"]> & {
|
|
$entity: "subwayStation";
|
|
};
|
|
};
|
|
FilterUnit: BaseStation.OpFilter & {
|
|
area: MakeFilter<Area["FilterUnit"]>;
|
|
subwayStation$station: MakeFilter<Omit<SubwayStation["FilterUnit"], "station">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Station["FilterUnit"]>;
|
|
SortAttr: Partial<BaseStation.OpSortAttr | {
|
|
area: Area["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Station["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Station["SortNode"][];
|
|
Selection: OakSelection<"select", Station["Projection"], Station["Filter"], Station["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Station["Projection"], Station["Filter"], Station["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseStation.OpSchema & {
|
|
subwayStation$station?: (OakOperation<"create", Omit<SubwayStation["CreateOperationData"], "station"> | Omit<SubwayStation["CreateOperationData"], "station">[]> | OakOperation<BaseSubwayStation.OpUpdateAction, Omit<SubwayStation["UpdateOperationData"], "station">, SubwayStation["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Station["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Station["CreateOperationData"]>>;
|
|
Create: Station["CreateSingle"] | Station["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseStation.OpSchema & {
|
|
subwayStation$station?: (OakOperation<"create", Omit<SubwayStation["CreateOperationData"], "station"> | Omit<SubwayStation["CreateOperationData"], "station">[]> | OakOperation<BaseSubwayStation.OpUpdateAction, Omit<SubwayStation["UpdateOperationData"], "station">, SubwayStation["Filter"]> | OakOperation<"remove", SubwayStation["RemoveOperationData"], SubwayStation["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseStation.OpUpdateAction, Station["UpdateOperationData"], Station["Filter"], Station["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Station["RemoveOperationData"], Station["Filter"], Station["Sorter"]>;
|
|
Operation: Station["Create"] | Station["Update"] | Station["Remove"];
|
|
};
|
|
export type Subscription = {
|
|
OpSchema: BaseSubscription.OpSchema;
|
|
Action: BaseSubscription.OpAction;
|
|
Schema: BaseSubscription.OpSchema & {};
|
|
Projection: BaseSubscription.OpProjection & {};
|
|
FilterUnit: BaseSubscription.OpFilter & {};
|
|
Filter: MakeFilter<Subscription["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSubscription.OpSortAttr | {}>;
|
|
SortNode: {
|
|
$attr: Subscription["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Subscription["SortNode"][];
|
|
Selection: OakSelection<"select", Subscription["Projection"], Subscription["Filter"], Subscription["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Subscription["Projection"], Subscription["Filter"], Subscription["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSubscription.OpSchema>;
|
|
CreateSingle: OakOperation<"create", Subscription["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Subscription["CreateOperationData"]>>;
|
|
Create: Subscription["CreateSingle"] | Subscription["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSubscription.OpSchema>;
|
|
Update: OakOperation<BaseSubscription.OpUpdateAction, Subscription["UpdateOperationData"], Subscription["Filter"], Subscription["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Subscription["RemoveOperationData"], Subscription["Filter"], Subscription["Sorter"]>;
|
|
Operation: Subscription["Create"] | Subscription["Update"] | Subscription["Remove"];
|
|
};
|
|
export type Subway = {
|
|
OpSchema: BaseSubway.OpSchema;
|
|
Action: BaseSubway.OpAction;
|
|
Schema: BaseSubway.OpSchema & {
|
|
area: Area["Schema"];
|
|
subwayStation$subway?: Array<Omit<SubwayStation["Schema"], "subway">>;
|
|
subwayStation$subway$$aggr?: AggregationResult<Omit<SubwayStation["Schema"], "subway">>;
|
|
};
|
|
Projection: BaseSubway.OpProjection & {
|
|
area?: Area["Projection"];
|
|
subwayStation$subway?: OakSelection<"select", Omit<SubwayStation["Projection"], "subway">, Omit<SubwayStation["Filter"], "subway">, SubwayStation["Sorter"]> & {
|
|
$entity: "subwayStation";
|
|
};
|
|
subwayStation$subway$$aggr?: DeduceAggregation<Omit<SubwayStation["Projection"], "subway">, Omit<SubwayStation["Filter"], "subway">, SubwayStation["Sorter"]> & {
|
|
$entity: "subwayStation";
|
|
};
|
|
};
|
|
FilterUnit: BaseSubway.OpFilter & {
|
|
area: MakeFilter<Area["FilterUnit"]>;
|
|
subwayStation$subway: MakeFilter<Omit<SubwayStation["FilterUnit"], "subway">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Subway["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSubway.OpSortAttr | {
|
|
area: Area["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Subway["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Subway["SortNode"][];
|
|
Selection: OakSelection<"select", Subway["Projection"], Subway["Filter"], Subway["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Subway["Projection"], Subway["Filter"], Subway["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSubway.OpSchema & {
|
|
subwayStation$subway?: (OakOperation<"create", Omit<SubwayStation["CreateOperationData"], "subway"> | Omit<SubwayStation["CreateOperationData"], "subway">[]> | OakOperation<BaseSubwayStation.OpUpdateAction, Omit<SubwayStation["UpdateOperationData"], "subway">, SubwayStation["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Subway["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Subway["CreateOperationData"]>>;
|
|
Create: Subway["CreateSingle"] | Subway["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSubway.OpSchema & {
|
|
subwayStation$subway?: (OakOperation<"create", Omit<SubwayStation["CreateOperationData"], "subway"> | Omit<SubwayStation["CreateOperationData"], "subway">[]> | OakOperation<BaseSubwayStation.OpUpdateAction, Omit<SubwayStation["UpdateOperationData"], "subway">, SubwayStation["Filter"]> | OakOperation<"remove", SubwayStation["RemoveOperationData"], SubwayStation["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseSubway.OpUpdateAction, Subway["UpdateOperationData"], Subway["Filter"], Subway["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Subway["RemoveOperationData"], Subway["Filter"], Subway["Sorter"]>;
|
|
Operation: Subway["Create"] | Subway["Update"] | Subway["Remove"];
|
|
};
|
|
export type SubwayStation = {
|
|
OpSchema: BaseSubwayStation.OpSchema;
|
|
Action: BaseSubwayStation.OpAction;
|
|
Schema: BaseSubwayStation.OpSchema & {
|
|
station: Station["Schema"];
|
|
subway: Subway["Schema"];
|
|
};
|
|
Projection: BaseSubwayStation.OpProjection & {
|
|
station?: Station["Projection"];
|
|
subway?: Subway["Projection"];
|
|
};
|
|
FilterUnit: BaseSubwayStation.OpFilter & {
|
|
station: MakeFilter<Station["FilterUnit"]>;
|
|
subway: MakeFilter<Subway["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<SubwayStation["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSubwayStation.OpSortAttr | {
|
|
station: Station["SortAttr"];
|
|
subway: Subway["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: SubwayStation["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: SubwayStation["SortNode"][];
|
|
Selection: OakSelection<"select", SubwayStation["Projection"], SubwayStation["Filter"], SubwayStation["Sorter"]>;
|
|
Aggregation: DeduceAggregation<SubwayStation["Projection"], SubwayStation["Filter"], SubwayStation["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSubwayStation.OpSchema & {
|
|
station?: OakOperation<"create", Station["CreateOperationData"]> | OakOperation<BaseStation.OpUpdateAction, Station["UpdateOperationData"], Station["Filter"]>;
|
|
subway?: OakOperation<"create", Subway["CreateOperationData"]> | OakOperation<BaseSubway.OpUpdateAction, Subway["UpdateOperationData"], Subway["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", SubwayStation["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<SubwayStation["CreateOperationData"]>>;
|
|
Create: SubwayStation["CreateSingle"] | SubwayStation["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSubwayStation.OpSchema & {
|
|
station?: OakOperation<"create", Station["CreateOperationData"]> | OakOperation<BaseStation.OpUpdateAction, Station["UpdateOperationData"], Station["Filter"]> | OakOperation<"remove", Station["RemoveOperationData"], Station["Filter"]>;
|
|
subway?: OakOperation<"create", Subway["CreateOperationData"]> | OakOperation<BaseSubway.OpUpdateAction, Subway["UpdateOperationData"], Subway["Filter"]> | OakOperation<"remove", Subway["RemoveOperationData"], Subway["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseSubwayStation.OpUpdateAction, SubwayStation["UpdateOperationData"], SubwayStation["Filter"], SubwayStation["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", SubwayStation["RemoveOperationData"], SubwayStation["Filter"], SubwayStation["Sorter"]>;
|
|
Operation: SubwayStation["Create"] | SubwayStation["Update"] | SubwayStation["Remove"];
|
|
};
|
|
export type System = {
|
|
OpSchema: BaseSystem.OpSchema;
|
|
Action: BaseSystem.OpAction;
|
|
Schema: BaseSystem.OpSchema & {
|
|
platform?: Platform["Schema"];
|
|
application$system?: Array<Omit<Application["Schema"], "system">>;
|
|
domain$system?: Array<Omit<Domain["Schema"], "system">>;
|
|
messageSystem$system?: Array<Omit<MessageSystem["Schema"], "system">>;
|
|
oauthApplication$system?: Array<Omit<OauthApplication["Schema"], "system">>;
|
|
oauthProvider$system?: Array<Omit<OauthProvider["Schema"], "system">>;
|
|
passport$system?: Array<Omit<Passport["Schema"], "system">>;
|
|
smsTemplate$system?: Array<Omit<SmsTemplate["Schema"], "system">>;
|
|
userSystem$system?: Array<Omit<UserSystem["Schema"], "system">>;
|
|
abstractPayAccount$system?: Array<Omit<AbstractPayAccount["Schema"], "system">>;
|
|
abstractShipAccount$system?: Array<Omit<AbstractShipAccount["Schema"], "system">>;
|
|
account$ofSystem?: Array<Omit<Account["Schema"], "ofSystem">>;
|
|
account$entity?: Array<Omit<Account["Schema"], "entity">>;
|
|
aliPay$system?: Array<Omit<AliPay["Schema"], "system">>;
|
|
apAccount$system?: Array<Omit<ApAccount["Schema"], "system">>;
|
|
offlineAccount$system?: Array<Omit<OfflineAccount["Schema"], "system">>;
|
|
order$system?: Array<Omit<Order["Schema"], "system">>;
|
|
shipServiceSystem$system?: Array<Omit<ShipServiceSystem["Schema"], "system">>;
|
|
sysAccountMove$system?: Array<Omit<SysAccountMove["Schema"], "system">>;
|
|
wechatMpShip$system?: Array<Omit<WechatMpShip["Schema"], "system">>;
|
|
wechatPay$system?: Array<Omit<WechatPay["Schema"], "system">>;
|
|
withdrawAccount$ofSystem?: Array<Omit<WithdrawAccount["Schema"], "ofSystem">>;
|
|
withdrawAccount$entity?: Array<Omit<WithdrawAccount["Schema"], "entity">>;
|
|
withdrawChannel$system?: Array<Omit<WithdrawChannel["Schema"], "system">>;
|
|
wpAccount$system?: Array<Omit<WpAccount["Schema"], "system">>;
|
|
application$system$$aggr?: AggregationResult<Omit<Application["Schema"], "system">>;
|
|
domain$system$$aggr?: AggregationResult<Omit<Domain["Schema"], "system">>;
|
|
messageSystem$system$$aggr?: AggregationResult<Omit<MessageSystem["Schema"], "system">>;
|
|
oauthApplication$system$$aggr?: AggregationResult<Omit<OauthApplication["Schema"], "system">>;
|
|
oauthProvider$system$$aggr?: AggregationResult<Omit<OauthProvider["Schema"], "system">>;
|
|
passport$system$$aggr?: AggregationResult<Omit<Passport["Schema"], "system">>;
|
|
smsTemplate$system$$aggr?: AggregationResult<Omit<SmsTemplate["Schema"], "system">>;
|
|
userSystem$system$$aggr?: AggregationResult<Omit<UserSystem["Schema"], "system">>;
|
|
abstractPayAccount$system$$aggr?: AggregationResult<Omit<AbstractPayAccount["Schema"], "system">>;
|
|
abstractShipAccount$system$$aggr?: AggregationResult<Omit<AbstractShipAccount["Schema"], "system">>;
|
|
account$ofSystem$$aggr?: AggregationResult<Omit<Account["Schema"], "ofSystem">>;
|
|
account$entity$$aggr?: AggregationResult<Omit<Account["Schema"], "entity">>;
|
|
aliPay$system$$aggr?: AggregationResult<Omit<AliPay["Schema"], "system">>;
|
|
apAccount$system$$aggr?: AggregationResult<Omit<ApAccount["Schema"], "system">>;
|
|
offlineAccount$system$$aggr?: AggregationResult<Omit<OfflineAccount["Schema"], "system">>;
|
|
order$system$$aggr?: AggregationResult<Omit<Order["Schema"], "system">>;
|
|
shipServiceSystem$system$$aggr?: AggregationResult<Omit<ShipServiceSystem["Schema"], "system">>;
|
|
sysAccountMove$system$$aggr?: AggregationResult<Omit<SysAccountMove["Schema"], "system">>;
|
|
wechatMpShip$system$$aggr?: AggregationResult<Omit<WechatMpShip["Schema"], "system">>;
|
|
wechatPay$system$$aggr?: AggregationResult<Omit<WechatPay["Schema"], "system">>;
|
|
withdrawAccount$ofSystem$$aggr?: AggregationResult<Omit<WithdrawAccount["Schema"], "ofSystem">>;
|
|
withdrawAccount$entity$$aggr?: AggregationResult<Omit<WithdrawAccount["Schema"], "entity">>;
|
|
withdrawChannel$system$$aggr?: AggregationResult<Omit<WithdrawChannel["Schema"], "system">>;
|
|
wpAccount$system$$aggr?: AggregationResult<Omit<WpAccount["Schema"], "system">>;
|
|
};
|
|
Projection: BaseSystem.OpProjection & {
|
|
platform?: Platform["Projection"];
|
|
application$system?: OakSelection<"select", Omit<Application["Projection"], "system">, Omit<Application["Filter"], "system">, Application["Sorter"]> & {
|
|
$entity: "application";
|
|
};
|
|
application$system$$aggr?: DeduceAggregation<Omit<Application["Projection"], "system">, Omit<Application["Filter"], "system">, Application["Sorter"]> & {
|
|
$entity: "application";
|
|
};
|
|
domain$system?: OakSelection<"select", Omit<Domain["Projection"], "system">, Omit<Domain["Filter"], "system">, Domain["Sorter"]> & {
|
|
$entity: "domain";
|
|
};
|
|
domain$system$$aggr?: DeduceAggregation<Omit<Domain["Projection"], "system">, Omit<Domain["Filter"], "system">, Domain["Sorter"]> & {
|
|
$entity: "domain";
|
|
};
|
|
messageSystem$system?: OakSelection<"select", Omit<MessageSystem["Projection"], "system">, Omit<MessageSystem["Filter"], "system">, MessageSystem["Sorter"]> & {
|
|
$entity: "messageSystem";
|
|
};
|
|
messageSystem$system$$aggr?: DeduceAggregation<Omit<MessageSystem["Projection"], "system">, Omit<MessageSystem["Filter"], "system">, MessageSystem["Sorter"]> & {
|
|
$entity: "messageSystem";
|
|
};
|
|
oauthApplication$system?: OakSelection<"select", Omit<OauthApplication["Projection"], "system">, Omit<OauthApplication["Filter"], "system">, OauthApplication["Sorter"]> & {
|
|
$entity: "oauthApplication";
|
|
};
|
|
oauthApplication$system$$aggr?: DeduceAggregation<Omit<OauthApplication["Projection"], "system">, Omit<OauthApplication["Filter"], "system">, OauthApplication["Sorter"]> & {
|
|
$entity: "oauthApplication";
|
|
};
|
|
oauthProvider$system?: OakSelection<"select", Omit<OauthProvider["Projection"], "system">, Omit<OauthProvider["Filter"], "system">, OauthProvider["Sorter"]> & {
|
|
$entity: "oauthProvider";
|
|
};
|
|
oauthProvider$system$$aggr?: DeduceAggregation<Omit<OauthProvider["Projection"], "system">, Omit<OauthProvider["Filter"], "system">, OauthProvider["Sorter"]> & {
|
|
$entity: "oauthProvider";
|
|
};
|
|
passport$system?: OakSelection<"select", Omit<Passport["Projection"], "system">, Omit<Passport["Filter"], "system">, Passport["Sorter"]> & {
|
|
$entity: "passport";
|
|
};
|
|
passport$system$$aggr?: DeduceAggregation<Omit<Passport["Projection"], "system">, Omit<Passport["Filter"], "system">, Passport["Sorter"]> & {
|
|
$entity: "passport";
|
|
};
|
|
smsTemplate$system?: OakSelection<"select", Omit<SmsTemplate["Projection"], "system">, Omit<SmsTemplate["Filter"], "system">, SmsTemplate["Sorter"]> & {
|
|
$entity: "smsTemplate";
|
|
};
|
|
smsTemplate$system$$aggr?: DeduceAggregation<Omit<SmsTemplate["Projection"], "system">, Omit<SmsTemplate["Filter"], "system">, SmsTemplate["Sorter"]> & {
|
|
$entity: "smsTemplate";
|
|
};
|
|
userSystem$system?: OakSelection<"select", Omit<UserSystem["Projection"], "system">, Omit<UserSystem["Filter"], "system">, UserSystem["Sorter"]> & {
|
|
$entity: "userSystem";
|
|
};
|
|
userSystem$system$$aggr?: DeduceAggregation<Omit<UserSystem["Projection"], "system">, Omit<UserSystem["Filter"], "system">, UserSystem["Sorter"]> & {
|
|
$entity: "userSystem";
|
|
};
|
|
abstractPayAccount$system?: OakSelection<"select", Omit<AbstractPayAccount["Projection"], "system">, Omit<AbstractPayAccount["Filter"], "system">, AbstractPayAccount["Sorter"]> & {
|
|
$entity: "abstractPayAccount";
|
|
};
|
|
abstractPayAccount$system$$aggr?: DeduceAggregation<Omit<AbstractPayAccount["Projection"], "system">, Omit<AbstractPayAccount["Filter"], "system">, AbstractPayAccount["Sorter"]> & {
|
|
$entity: "abstractPayAccount";
|
|
};
|
|
abstractShipAccount$system?: OakSelection<"select", Omit<AbstractShipAccount["Projection"], "system">, Omit<AbstractShipAccount["Filter"], "system">, AbstractShipAccount["Sorter"]> & {
|
|
$entity: "abstractShipAccount";
|
|
};
|
|
abstractShipAccount$system$$aggr?: DeduceAggregation<Omit<AbstractShipAccount["Projection"], "system">, Omit<AbstractShipAccount["Filter"], "system">, AbstractShipAccount["Sorter"]> & {
|
|
$entity: "abstractShipAccount";
|
|
};
|
|
account$ofSystem?: OakSelection<"select", Omit<Account["Projection"], "system">, Omit<Account["Filter"], "system">, Account["Sorter"]> & {
|
|
$entity: "account";
|
|
};
|
|
account$ofSystem$$aggr?: DeduceAggregation<Omit<Account["Projection"], "system">, Omit<Account["Filter"], "system">, Account["Sorter"]> & {
|
|
$entity: "account";
|
|
};
|
|
account$entity?: OakSelection<"select", Omit<Account["Projection"], "system">, Omit<Account["Filter"], "system">, Account["Sorter"]> & {
|
|
$entity: "account";
|
|
};
|
|
account$entity$$aggr?: DeduceAggregation<Omit<Account["Projection"], "system">, Omit<Account["Filter"], "system">, Account["Sorter"]> & {
|
|
$entity: "account";
|
|
};
|
|
aliPay$system?: OakSelection<"select", Omit<AliPay["Projection"], "system">, Omit<AliPay["Filter"], "system">, AliPay["Sorter"]> & {
|
|
$entity: "aliPay";
|
|
};
|
|
aliPay$system$$aggr?: DeduceAggregation<Omit<AliPay["Projection"], "system">, Omit<AliPay["Filter"], "system">, AliPay["Sorter"]> & {
|
|
$entity: "aliPay";
|
|
};
|
|
apAccount$system?: OakSelection<"select", Omit<ApAccount["Projection"], "system">, Omit<ApAccount["Filter"], "system">, ApAccount["Sorter"]> & {
|
|
$entity: "apAccount";
|
|
};
|
|
apAccount$system$$aggr?: DeduceAggregation<Omit<ApAccount["Projection"], "system">, Omit<ApAccount["Filter"], "system">, ApAccount["Sorter"]> & {
|
|
$entity: "apAccount";
|
|
};
|
|
offlineAccount$system?: OakSelection<"select", Omit<OfflineAccount["Projection"], "system">, Omit<OfflineAccount["Filter"], "system">, OfflineAccount["Sorter"]> & {
|
|
$entity: "offlineAccount";
|
|
};
|
|
offlineAccount$system$$aggr?: DeduceAggregation<Omit<OfflineAccount["Projection"], "system">, Omit<OfflineAccount["Filter"], "system">, OfflineAccount["Sorter"]> & {
|
|
$entity: "offlineAccount";
|
|
};
|
|
order$system?: OakSelection<"select", Omit<Order["Projection"], "system">, Omit<Order["Filter"], "system">, Order["Sorter"]> & {
|
|
$entity: "order";
|
|
};
|
|
order$system$$aggr?: DeduceAggregation<Omit<Order["Projection"], "system">, Omit<Order["Filter"], "system">, Order["Sorter"]> & {
|
|
$entity: "order";
|
|
};
|
|
shipServiceSystem$system?: OakSelection<"select", Omit<ShipServiceSystem["Projection"], "system">, Omit<ShipServiceSystem["Filter"], "system">, ShipServiceSystem["Sorter"]> & {
|
|
$entity: "shipServiceSystem";
|
|
};
|
|
shipServiceSystem$system$$aggr?: DeduceAggregation<Omit<ShipServiceSystem["Projection"], "system">, Omit<ShipServiceSystem["Filter"], "system">, ShipServiceSystem["Sorter"]> & {
|
|
$entity: "shipServiceSystem";
|
|
};
|
|
sysAccountMove$system?: OakSelection<"select", Omit<SysAccountMove["Projection"], "system">, Omit<SysAccountMove["Filter"], "system">, SysAccountMove["Sorter"]> & {
|
|
$entity: "sysAccountMove";
|
|
};
|
|
sysAccountMove$system$$aggr?: DeduceAggregation<Omit<SysAccountMove["Projection"], "system">, Omit<SysAccountMove["Filter"], "system">, SysAccountMove["Sorter"]> & {
|
|
$entity: "sysAccountMove";
|
|
};
|
|
wechatMpShip$system?: OakSelection<"select", Omit<WechatMpShip["Projection"], "system">, Omit<WechatMpShip["Filter"], "system">, WechatMpShip["Sorter"]> & {
|
|
$entity: "wechatMpShip";
|
|
};
|
|
wechatMpShip$system$$aggr?: DeduceAggregation<Omit<WechatMpShip["Projection"], "system">, Omit<WechatMpShip["Filter"], "system">, WechatMpShip["Sorter"]> & {
|
|
$entity: "wechatMpShip";
|
|
};
|
|
wechatPay$system?: OakSelection<"select", Omit<WechatPay["Projection"], "system">, Omit<WechatPay["Filter"], "system">, WechatPay["Sorter"]> & {
|
|
$entity: "wechatPay";
|
|
};
|
|
wechatPay$system$$aggr?: DeduceAggregation<Omit<WechatPay["Projection"], "system">, Omit<WechatPay["Filter"], "system">, WechatPay["Sorter"]> & {
|
|
$entity: "wechatPay";
|
|
};
|
|
withdrawAccount$ofSystem?: OakSelection<"select", Omit<WithdrawAccount["Projection"], "system">, Omit<WithdrawAccount["Filter"], "system">, WithdrawAccount["Sorter"]> & {
|
|
$entity: "withdrawAccount";
|
|
};
|
|
withdrawAccount$ofSystem$$aggr?: DeduceAggregation<Omit<WithdrawAccount["Projection"], "system">, Omit<WithdrawAccount["Filter"], "system">, WithdrawAccount["Sorter"]> & {
|
|
$entity: "withdrawAccount";
|
|
};
|
|
withdrawAccount$entity?: OakSelection<"select", Omit<WithdrawAccount["Projection"], "system">, Omit<WithdrawAccount["Filter"], "system">, WithdrawAccount["Sorter"]> & {
|
|
$entity: "withdrawAccount";
|
|
};
|
|
withdrawAccount$entity$$aggr?: DeduceAggregation<Omit<WithdrawAccount["Projection"], "system">, Omit<WithdrawAccount["Filter"], "system">, WithdrawAccount["Sorter"]> & {
|
|
$entity: "withdrawAccount";
|
|
};
|
|
withdrawChannel$system?: OakSelection<"select", Omit<WithdrawChannel["Projection"], "system">, Omit<WithdrawChannel["Filter"], "system">, WithdrawChannel["Sorter"]> & {
|
|
$entity: "withdrawChannel";
|
|
};
|
|
withdrawChannel$system$$aggr?: DeduceAggregation<Omit<WithdrawChannel["Projection"], "system">, Omit<WithdrawChannel["Filter"], "system">, WithdrawChannel["Sorter"]> & {
|
|
$entity: "withdrawChannel";
|
|
};
|
|
wpAccount$system?: OakSelection<"select", Omit<WpAccount["Projection"], "system">, Omit<WpAccount["Filter"], "system">, WpAccount["Sorter"]> & {
|
|
$entity: "wpAccount";
|
|
};
|
|
wpAccount$system$$aggr?: DeduceAggregation<Omit<WpAccount["Projection"], "system">, Omit<WpAccount["Filter"], "system">, WpAccount["Sorter"]> & {
|
|
$entity: "wpAccount";
|
|
};
|
|
};
|
|
FilterUnit: BaseSystem.OpFilter & {
|
|
platform: MakeFilter<Platform["FilterUnit"]>;
|
|
application$system: MakeFilter<Omit<Application["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
domain$system: MakeFilter<Omit<Domain["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
messageSystem$system: MakeFilter<Omit<MessageSystem["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
oauthApplication$system: MakeFilter<Omit<OauthApplication["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
oauthProvider$system: MakeFilter<Omit<OauthProvider["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
passport$system: MakeFilter<Omit<Passport["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
smsTemplate$system: MakeFilter<Omit<SmsTemplate["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
userSystem$system: MakeFilter<Omit<UserSystem["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
abstractPayAccount$system: MakeFilter<Omit<AbstractPayAccount["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
abstractShipAccount$system: MakeFilter<Omit<AbstractShipAccount["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
account$ofSystem: MakeFilter<Omit<Account["FilterUnit"], "ofSystem">> & SubQueryPredicateMetadata;
|
|
account$entity: MakeFilter<Omit<Account["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
aliPay$system: MakeFilter<Omit<AliPay["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
apAccount$system: MakeFilter<Omit<ApAccount["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
offlineAccount$system: MakeFilter<Omit<OfflineAccount["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
order$system: MakeFilter<Omit<Order["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
shipServiceSystem$system: MakeFilter<Omit<ShipServiceSystem["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
sysAccountMove$system: MakeFilter<Omit<SysAccountMove["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
wechatMpShip$system: MakeFilter<Omit<WechatMpShip["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
wechatPay$system: MakeFilter<Omit<WechatPay["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
withdrawAccount$ofSystem: MakeFilter<Omit<WithdrawAccount["FilterUnit"], "ofSystem">> & SubQueryPredicateMetadata;
|
|
withdrawAccount$entity: MakeFilter<Omit<WithdrawAccount["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
withdrawChannel$system: MakeFilter<Omit<WithdrawChannel["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
wpAccount$system: MakeFilter<Omit<WpAccount["FilterUnit"], "system">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<System["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSystem.OpSortAttr | {
|
|
platform: Platform["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: System["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: System["SortNode"][];
|
|
Selection: OakSelection<"select", System["Projection"], System["Filter"], System["Sorter"]>;
|
|
Aggregation: DeduceAggregation<System["Projection"], System["Filter"], System["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSystem.OpSchema & {
|
|
platform?: OakOperation<"create", Platform["CreateOperationData"]> | OakOperation<BasePlatform.OpUpdateAction, Platform["UpdateOperationData"], Platform["Filter"]>;
|
|
application$system?: (OakOperation<"create", Omit<Application["CreateOperationData"], "system"> | Omit<Application["CreateOperationData"], "system">[]> | OakOperation<BaseApplication.OpUpdateAction, Omit<Application["UpdateOperationData"], "system">, Application["Filter"]>)[];
|
|
domain$system?: (OakOperation<"create", Omit<Domain["CreateOperationData"], "system"> | Omit<Domain["CreateOperationData"], "system">[]> | OakOperation<BaseDomain.OpUpdateAction, Omit<Domain["UpdateOperationData"], "system">, Domain["Filter"]>)[];
|
|
messageSystem$system?: (OakOperation<"create", Omit<MessageSystem["CreateOperationData"], "system"> | Omit<MessageSystem["CreateOperationData"], "system">[]> | OakOperation<BaseMessageSystem.OpUpdateAction, Omit<MessageSystem["UpdateOperationData"], "system">, MessageSystem["Filter"]>)[];
|
|
oauthApplication$system?: (OakOperation<"create", Omit<OauthApplication["CreateOperationData"], "system"> | Omit<OauthApplication["CreateOperationData"], "system">[]> | OakOperation<BaseOauthApplication.OpUpdateAction, Omit<OauthApplication["UpdateOperationData"], "system">, OauthApplication["Filter"]>)[];
|
|
oauthProvider$system?: (OakOperation<"create", Omit<OauthProvider["CreateOperationData"], "system"> | Omit<OauthProvider["CreateOperationData"], "system">[]> | OakOperation<BaseOauthProvider.OpUpdateAction, Omit<OauthProvider["UpdateOperationData"], "system">, OauthProvider["Filter"]>)[];
|
|
passport$system?: (OakOperation<"create", Omit<Passport["CreateOperationData"], "system"> | Omit<Passport["CreateOperationData"], "system">[]> | OakOperation<BasePassport.OpUpdateAction, Omit<Passport["UpdateOperationData"], "system">, Passport["Filter"]>)[];
|
|
smsTemplate$system?: (OakOperation<"create", Omit<SmsTemplate["CreateOperationData"], "system"> | Omit<SmsTemplate["CreateOperationData"], "system">[]> | OakOperation<BaseSmsTemplate.OpUpdateAction, Omit<SmsTemplate["UpdateOperationData"], "system">, SmsTemplate["Filter"]>)[];
|
|
userSystem$system?: (OakOperation<"create", Omit<UserSystem["CreateOperationData"], "system"> | Omit<UserSystem["CreateOperationData"], "system">[]> | OakOperation<BaseUserSystem.OpUpdateAction, Omit<UserSystem["UpdateOperationData"], "system">, UserSystem["Filter"]>)[];
|
|
abstractPayAccount$system?: (OakOperation<"create", Omit<AbstractPayAccount["CreateOperationData"], "system"> | Omit<AbstractPayAccount["CreateOperationData"], "system">[]> | OakOperation<BaseAbstractPayAccount.OpUpdateAction, Omit<AbstractPayAccount["UpdateOperationData"], "system">, AbstractPayAccount["Filter"]>)[];
|
|
abstractShipAccount$system?: (OakOperation<"create", Omit<AbstractShipAccount["CreateOperationData"], "system"> | Omit<AbstractShipAccount["CreateOperationData"], "system">[]> | OakOperation<BaseAbstractShipAccount.OpUpdateAction, Omit<AbstractShipAccount["UpdateOperationData"], "system">, AbstractShipAccount["Filter"]>)[];
|
|
account$ofSystem?: (OakOperation<"create", Omit<Account["CreateOperationData"], "ofSystem"> | Omit<Account["CreateOperationData"], "ofSystem">[]> | OakOperation<BaseAccount.OpUpdateAction, Omit<Account["UpdateOperationData"], "ofSystem">, Account["Filter"]>)[];
|
|
account$entity?: (OakOperation<"create", Omit<Account["CreateOperationData"], "system"> | Omit<Account["CreateOperationData"], "system">[]> | OakOperation<BaseAccount.OpUpdateAction, Omit<Account["UpdateOperationData"], "system">, Account["Filter"]>)[];
|
|
aliPay$system?: (OakOperation<"create", Omit<AliPay["CreateOperationData"], "system"> | Omit<AliPay["CreateOperationData"], "system">[]> | OakOperation<BaseAliPay.OpUpdateAction, Omit<AliPay["UpdateOperationData"], "system">, AliPay["Filter"]>)[];
|
|
apAccount$system?: (OakOperation<"create", Omit<ApAccount["CreateOperationData"], "system"> | Omit<ApAccount["CreateOperationData"], "system">[]> | OakOperation<BaseApAccount.OpUpdateAction, Omit<ApAccount["UpdateOperationData"], "system">, ApAccount["Filter"]>)[];
|
|
offlineAccount$system?: (OakOperation<"create", Omit<OfflineAccount["CreateOperationData"], "system"> | Omit<OfflineAccount["CreateOperationData"], "system">[]> | OakOperation<BaseOfflineAccount.OpUpdateAction, Omit<OfflineAccount["UpdateOperationData"], "system">, OfflineAccount["Filter"]>)[];
|
|
order$system?: (OakOperation<"create", Omit<Order["CreateOperationData"], "system"> | Omit<Order["CreateOperationData"], "system">[]> | OakOperation<BaseOrder.OpUpdateAction, Omit<Order["UpdateOperationData"], "system">, Order["Filter"]>)[];
|
|
shipServiceSystem$system?: (OakOperation<"create", Omit<ShipServiceSystem["CreateOperationData"], "system"> | Omit<ShipServiceSystem["CreateOperationData"], "system">[]> | OakOperation<BaseShipServiceSystem.OpUpdateAction, Omit<ShipServiceSystem["UpdateOperationData"], "system">, ShipServiceSystem["Filter"]>)[];
|
|
sysAccountMove$system?: OakOperation<"create", Omit<SysAccountMove["CreateOperationData"], "system"> | Omit<SysAccountMove["CreateOperationData"], "system">[]>[];
|
|
wechatMpShip$system?: (OakOperation<"create", Omit<WechatMpShip["CreateOperationData"], "system"> | Omit<WechatMpShip["CreateOperationData"], "system">[]> | OakOperation<BaseWechatMpShip.OpUpdateAction, Omit<WechatMpShip["UpdateOperationData"], "system">, WechatMpShip["Filter"]>)[];
|
|
wechatPay$system?: (OakOperation<"create", Omit<WechatPay["CreateOperationData"], "system"> | Omit<WechatPay["CreateOperationData"], "system">[]> | OakOperation<BaseWechatPay.OpUpdateAction, Omit<WechatPay["UpdateOperationData"], "system">, WechatPay["Filter"]>)[];
|
|
withdrawAccount$ofSystem?: (OakOperation<"create", Omit<WithdrawAccount["CreateOperationData"], "ofSystem"> | Omit<WithdrawAccount["CreateOperationData"], "ofSystem">[]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, Omit<WithdrawAccount["UpdateOperationData"], "ofSystem">, WithdrawAccount["Filter"]>)[];
|
|
withdrawAccount$entity?: (OakOperation<"create", Omit<WithdrawAccount["CreateOperationData"], "system"> | Omit<WithdrawAccount["CreateOperationData"], "system">[]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, Omit<WithdrawAccount["UpdateOperationData"], "system">, WithdrawAccount["Filter"]>)[];
|
|
withdrawChannel$system?: (OakOperation<"create", Omit<WithdrawChannel["CreateOperationData"], "system"> | Omit<WithdrawChannel["CreateOperationData"], "system">[]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, Omit<WithdrawChannel["UpdateOperationData"], "system">, WithdrawChannel["Filter"]>)[];
|
|
wpAccount$system?: (OakOperation<"create", Omit<WpAccount["CreateOperationData"], "system"> | Omit<WpAccount["CreateOperationData"], "system">[]> | OakOperation<BaseWpAccount.OpUpdateAction, Omit<WpAccount["UpdateOperationData"], "system">, WpAccount["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", System["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<System["CreateOperationData"]>>;
|
|
Create: System["CreateSingle"] | System["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSystem.OpSchema & {
|
|
platform?: OakOperation<"create", Platform["CreateOperationData"]> | OakOperation<BasePlatform.OpUpdateAction, Platform["UpdateOperationData"], Platform["Filter"]> | OakOperation<"remove", Platform["RemoveOperationData"], Platform["Filter"]>;
|
|
application$system?: (OakOperation<"create", Omit<Application["CreateOperationData"], "system"> | Omit<Application["CreateOperationData"], "system">[]> | OakOperation<BaseApplication.OpUpdateAction, Omit<Application["UpdateOperationData"], "system">, Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>)[];
|
|
domain$system?: (OakOperation<"create", Omit<Domain["CreateOperationData"], "system"> | Omit<Domain["CreateOperationData"], "system">[]> | OakOperation<BaseDomain.OpUpdateAction, Omit<Domain["UpdateOperationData"], "system">, Domain["Filter"]> | OakOperation<"remove", Domain["RemoveOperationData"], Domain["Filter"]>)[];
|
|
messageSystem$system?: (OakOperation<"create", Omit<MessageSystem["CreateOperationData"], "system"> | Omit<MessageSystem["CreateOperationData"], "system">[]> | OakOperation<BaseMessageSystem.OpUpdateAction, Omit<MessageSystem["UpdateOperationData"], "system">, MessageSystem["Filter"]> | OakOperation<"remove", MessageSystem["RemoveOperationData"], MessageSystem["Filter"]>)[];
|
|
oauthApplication$system?: (OakOperation<"create", Omit<OauthApplication["CreateOperationData"], "system"> | Omit<OauthApplication["CreateOperationData"], "system">[]> | OakOperation<BaseOauthApplication.OpUpdateAction, Omit<OauthApplication["UpdateOperationData"], "system">, OauthApplication["Filter"]> | OakOperation<"remove", OauthApplication["RemoveOperationData"], OauthApplication["Filter"]>)[];
|
|
oauthProvider$system?: (OakOperation<"create", Omit<OauthProvider["CreateOperationData"], "system"> | Omit<OauthProvider["CreateOperationData"], "system">[]> | OakOperation<BaseOauthProvider.OpUpdateAction, Omit<OauthProvider["UpdateOperationData"], "system">, OauthProvider["Filter"]> | OakOperation<"remove", OauthProvider["RemoveOperationData"], OauthProvider["Filter"]>)[];
|
|
passport$system?: (OakOperation<"create", Omit<Passport["CreateOperationData"], "system"> | Omit<Passport["CreateOperationData"], "system">[]> | OakOperation<BasePassport.OpUpdateAction, Omit<Passport["UpdateOperationData"], "system">, Passport["Filter"]> | OakOperation<"remove", Passport["RemoveOperationData"], Passport["Filter"]>)[];
|
|
smsTemplate$system?: (OakOperation<"create", Omit<SmsTemplate["CreateOperationData"], "system"> | Omit<SmsTemplate["CreateOperationData"], "system">[]> | OakOperation<BaseSmsTemplate.OpUpdateAction, Omit<SmsTemplate["UpdateOperationData"], "system">, SmsTemplate["Filter"]> | OakOperation<"remove", SmsTemplate["RemoveOperationData"], SmsTemplate["Filter"]>)[];
|
|
userSystem$system?: (OakOperation<"create", Omit<UserSystem["CreateOperationData"], "system"> | Omit<UserSystem["CreateOperationData"], "system">[]> | OakOperation<BaseUserSystem.OpUpdateAction, Omit<UserSystem["UpdateOperationData"], "system">, UserSystem["Filter"]> | OakOperation<"remove", UserSystem["RemoveOperationData"], UserSystem["Filter"]>)[];
|
|
abstractPayAccount$system?: (OakOperation<"create", Omit<AbstractPayAccount["CreateOperationData"], "system"> | Omit<AbstractPayAccount["CreateOperationData"], "system">[]> | OakOperation<BaseAbstractPayAccount.OpUpdateAction, Omit<AbstractPayAccount["UpdateOperationData"], "system">, AbstractPayAccount["Filter"]> | OakOperation<"remove", AbstractPayAccount["RemoveOperationData"], AbstractPayAccount["Filter"]>)[];
|
|
abstractShipAccount$system?: (OakOperation<"create", Omit<AbstractShipAccount["CreateOperationData"], "system"> | Omit<AbstractShipAccount["CreateOperationData"], "system">[]> | OakOperation<BaseAbstractShipAccount.OpUpdateAction, Omit<AbstractShipAccount["UpdateOperationData"], "system">, AbstractShipAccount["Filter"]> | OakOperation<"remove", AbstractShipAccount["RemoveOperationData"], AbstractShipAccount["Filter"]>)[];
|
|
account$ofSystem?: (OakOperation<"create", Omit<Account["CreateOperationData"], "ofSystem"> | Omit<Account["CreateOperationData"], "ofSystem">[]> | OakOperation<BaseAccount.OpUpdateAction, Omit<Account["UpdateOperationData"], "ofSystem">, Account["Filter"]> | OakOperation<"remove", Account["RemoveOperationData"], Account["Filter"]>)[];
|
|
account$entity?: (OakOperation<"create", Omit<Account["CreateOperationData"], "system"> | Omit<Account["CreateOperationData"], "system">[]> | OakOperation<BaseAccount.OpUpdateAction, Omit<Account["UpdateOperationData"], "system">, Account["Filter"]> | OakOperation<"remove", Account["RemoveOperationData"], Account["Filter"]>)[];
|
|
aliPay$system?: (OakOperation<"create", Omit<AliPay["CreateOperationData"], "system"> | Omit<AliPay["CreateOperationData"], "system">[]> | OakOperation<BaseAliPay.OpUpdateAction, Omit<AliPay["UpdateOperationData"], "system">, AliPay["Filter"]> | OakOperation<"remove", AliPay["RemoveOperationData"], AliPay["Filter"]>)[];
|
|
apAccount$system?: (OakOperation<"create", Omit<ApAccount["CreateOperationData"], "system"> | Omit<ApAccount["CreateOperationData"], "system">[]> | OakOperation<BaseApAccount.OpUpdateAction, Omit<ApAccount["UpdateOperationData"], "system">, ApAccount["Filter"]> | OakOperation<"remove", ApAccount["RemoveOperationData"], ApAccount["Filter"]>)[];
|
|
offlineAccount$system?: (OakOperation<"create", Omit<OfflineAccount["CreateOperationData"], "system"> | Omit<OfflineAccount["CreateOperationData"], "system">[]> | OakOperation<BaseOfflineAccount.OpUpdateAction, Omit<OfflineAccount["UpdateOperationData"], "system">, OfflineAccount["Filter"]> | OakOperation<"remove", OfflineAccount["RemoveOperationData"], OfflineAccount["Filter"]>)[];
|
|
order$system?: (OakOperation<"create", Omit<Order["CreateOperationData"], "system"> | Omit<Order["CreateOperationData"], "system">[]> | OakOperation<BaseOrder.OpUpdateAction, Omit<Order["UpdateOperationData"], "system">, Order["Filter"]> | OakOperation<"remove", Order["RemoveOperationData"], Order["Filter"]>)[];
|
|
shipServiceSystem$system?: (OakOperation<"create", Omit<ShipServiceSystem["CreateOperationData"], "system"> | Omit<ShipServiceSystem["CreateOperationData"], "system">[]> | OakOperation<BaseShipServiceSystem.OpUpdateAction, Omit<ShipServiceSystem["UpdateOperationData"], "system">, ShipServiceSystem["Filter"]> | OakOperation<"remove", ShipServiceSystem["RemoveOperationData"], ShipServiceSystem["Filter"]>)[];
|
|
sysAccountMove$system?: OakOperation<"create", Omit<SysAccountMove["CreateOperationData"], "system"> | Omit<SysAccountMove["CreateOperationData"], "system">[]>[];
|
|
wechatMpShip$system?: (OakOperation<"create", Omit<WechatMpShip["CreateOperationData"], "system"> | Omit<WechatMpShip["CreateOperationData"], "system">[]> | OakOperation<BaseWechatMpShip.OpUpdateAction, Omit<WechatMpShip["UpdateOperationData"], "system">, WechatMpShip["Filter"]> | OakOperation<"remove", WechatMpShip["RemoveOperationData"], WechatMpShip["Filter"]>)[];
|
|
wechatPay$system?: (OakOperation<"create", Omit<WechatPay["CreateOperationData"], "system"> | Omit<WechatPay["CreateOperationData"], "system">[]> | OakOperation<BaseWechatPay.OpUpdateAction, Omit<WechatPay["UpdateOperationData"], "system">, WechatPay["Filter"]> | OakOperation<"remove", WechatPay["RemoveOperationData"], WechatPay["Filter"]>)[];
|
|
withdrawAccount$ofSystem?: (OakOperation<"create", Omit<WithdrawAccount["CreateOperationData"], "ofSystem"> | Omit<WithdrawAccount["CreateOperationData"], "ofSystem">[]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, Omit<WithdrawAccount["UpdateOperationData"], "ofSystem">, WithdrawAccount["Filter"]> | OakOperation<"remove", WithdrawAccount["RemoveOperationData"], WithdrawAccount["Filter"]>)[];
|
|
withdrawAccount$entity?: (OakOperation<"create", Omit<WithdrawAccount["CreateOperationData"], "system"> | Omit<WithdrawAccount["CreateOperationData"], "system">[]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, Omit<WithdrawAccount["UpdateOperationData"], "system">, WithdrawAccount["Filter"]> | OakOperation<"remove", WithdrawAccount["RemoveOperationData"], WithdrawAccount["Filter"]>)[];
|
|
withdrawChannel$system?: (OakOperation<"create", Omit<WithdrawChannel["CreateOperationData"], "system"> | Omit<WithdrawChannel["CreateOperationData"], "system">[]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, Omit<WithdrawChannel["UpdateOperationData"], "system">, WithdrawChannel["Filter"]> | OakOperation<"remove", WithdrawChannel["RemoveOperationData"], WithdrawChannel["Filter"]>)[];
|
|
wpAccount$system?: (OakOperation<"create", Omit<WpAccount["CreateOperationData"], "system"> | Omit<WpAccount["CreateOperationData"], "system">[]> | OakOperation<BaseWpAccount.OpUpdateAction, Omit<WpAccount["UpdateOperationData"], "system">, WpAccount["Filter"]> | OakOperation<"remove", WpAccount["RemoveOperationData"], WpAccount["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"], System["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", System["RemoveOperationData"], System["Filter"], System["Sorter"]>;
|
|
Operation: System["Create"] | System["Update"] | System["Remove"];
|
|
};
|
|
export type ToDo = {
|
|
OpSchema: BaseToDo.OpSchema;
|
|
Action: BaseToDo.OpAction;
|
|
Schema: BaseToDo.OpSchema & {
|
|
relation$entity?: Array<Omit<Relation["Schema"], "entity">>;
|
|
userRelation$entity?: Array<Omit<UserRelation["Schema"], "entity">>;
|
|
relation$entity$$aggr?: AggregationResult<Omit<Relation["Schema"], "entity">>;
|
|
userRelation$entity$$aggr?: AggregationResult<Omit<UserRelation["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseToDo.OpProjection & {
|
|
relation$entity?: OakSelection<"select", Omit<Relation["Projection"], "toDo">, Omit<Relation["Filter"], "toDo">, Relation["Sorter"]> & {
|
|
$entity: "relation";
|
|
};
|
|
relation$entity$$aggr?: DeduceAggregation<Omit<Relation["Projection"], "toDo">, Omit<Relation["Filter"], "toDo">, Relation["Sorter"]> & {
|
|
$entity: "relation";
|
|
};
|
|
userRelation$entity?: OakSelection<"select", Omit<UserRelation["Projection"], "toDo">, Omit<UserRelation["Filter"], "toDo">, UserRelation["Sorter"]> & {
|
|
$entity: "userRelation";
|
|
};
|
|
userRelation$entity$$aggr?: DeduceAggregation<Omit<UserRelation["Projection"], "toDo">, Omit<UserRelation["Filter"], "toDo">, UserRelation["Sorter"]> & {
|
|
$entity: "userRelation";
|
|
};
|
|
};
|
|
FilterUnit: BaseToDo.OpFilter & {
|
|
relation$entity: MakeFilter<Omit<Relation["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
userRelation$entity: MakeFilter<Omit<UserRelation["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<ToDo["FilterUnit"]>;
|
|
SortAttr: Partial<BaseToDo.OpSortAttr | {}>;
|
|
SortNode: {
|
|
$attr: ToDo["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ToDo["SortNode"][];
|
|
Selection: OakSelection<"select", ToDo["Projection"], ToDo["Filter"], ToDo["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ToDo["Projection"], ToDo["Filter"], ToDo["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseToDo.OpSchema & {
|
|
relation$entity?: (OakOperation<"create", Omit<Relation["CreateOperationData"], "toDo"> | Omit<Relation["CreateOperationData"], "toDo">[]> | OakOperation<BaseRelation.OpUpdateAction, Omit<Relation["UpdateOperationData"], "toDo">, Relation["Filter"]>)[];
|
|
userRelation$entity?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "toDo"> | Omit<UserRelation["CreateOperationData"], "toDo">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "toDo">, UserRelation["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ToDo["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ToDo["CreateOperationData"]>>;
|
|
Create: ToDo["CreateSingle"] | ToDo["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseToDo.OpSchema & {
|
|
relation$entity?: (OakOperation<"create", Omit<Relation["CreateOperationData"], "toDo"> | Omit<Relation["CreateOperationData"], "toDo">[]> | OakOperation<BaseRelation.OpUpdateAction, Omit<Relation["UpdateOperationData"], "toDo">, Relation["Filter"]> | OakOperation<"remove", Relation["RemoveOperationData"], Relation["Filter"]>)[];
|
|
userRelation$entity?: (OakOperation<"create", Omit<UserRelation["CreateOperationData"], "toDo"> | Omit<UserRelation["CreateOperationData"], "toDo">[]> | OakOperation<BaseUserRelation.OpUpdateAction, Omit<UserRelation["UpdateOperationData"], "toDo">, UserRelation["Filter"]> | OakOperation<"remove", UserRelation["RemoveOperationData"], UserRelation["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseToDo.OpUpdateAction, ToDo["UpdateOperationData"], ToDo["Filter"], ToDo["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ToDo["RemoveOperationData"], ToDo["Filter"], ToDo["Sorter"]>;
|
|
Operation: ToDo["Create"] | ToDo["Update"] | ToDo["Remove"];
|
|
};
|
|
export type Token = {
|
|
OpSchema: BaseToken.OpSchema;
|
|
Action: BaseToken.OpAction;
|
|
Schema: BaseToken.OpSchema & {
|
|
application?: Application["Schema"];
|
|
user?: User["Schema"];
|
|
player?: User["Schema"];
|
|
email?: Email["Schema"];
|
|
loginName?: LoginName["Schema"];
|
|
mobile?: Mobile["Schema"];
|
|
oauthUser?: OauthUser["Schema"];
|
|
parasite?: Parasite["Schema"];
|
|
wechatLogin?: WechatLogin["Schema"];
|
|
wechatUser?: WechatUser["Schema"];
|
|
};
|
|
Projection: BaseToken.OpProjection & {
|
|
application?: Application["Projection"];
|
|
user?: User["Projection"];
|
|
player?: User["Projection"];
|
|
email?: Email["Projection"];
|
|
loginName?: LoginName["Projection"];
|
|
mobile?: Mobile["Projection"];
|
|
oauthUser?: OauthUser["Projection"];
|
|
parasite?: Parasite["Projection"];
|
|
wechatLogin?: WechatLogin["Projection"];
|
|
wechatUser?: WechatUser["Projection"];
|
|
};
|
|
FilterUnit: BaseToken.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
player: MakeFilter<User["FilterUnit"]>;
|
|
email: MakeFilter<Email["FilterUnit"]>;
|
|
loginName: MakeFilter<LoginName["FilterUnit"]>;
|
|
mobile: MakeFilter<Mobile["FilterUnit"]>;
|
|
oauthUser: MakeFilter<OauthUser["FilterUnit"]>;
|
|
parasite: MakeFilter<Parasite["FilterUnit"]>;
|
|
wechatLogin: MakeFilter<WechatLogin["FilterUnit"]>;
|
|
wechatUser: MakeFilter<WechatUser["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<Token["FilterUnit"]>;
|
|
SortAttr: Partial<BaseToken.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
user: User["SortAttr"];
|
|
player: User["SortAttr"];
|
|
email: Email["SortAttr"];
|
|
loginName: LoginName["SortAttr"];
|
|
mobile: Mobile["SortAttr"];
|
|
oauthUser: OauthUser["SortAttr"];
|
|
parasite: Parasite["SortAttr"];
|
|
wechatLogin: WechatLogin["SortAttr"];
|
|
wechatUser: WechatUser["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Token["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Token["SortNode"][];
|
|
Selection: OakSelection<"select", Token["Projection"], Token["Filter"], Token["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Token["Projection"], Token["Filter"], Token["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseToken.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
player?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
email?: OakOperation<"create", Email["CreateOperationData"]> | OakOperation<BaseEmail.OpUpdateAction, Email["UpdateOperationData"], Email["Filter"]>;
|
|
loginName?: OakOperation<"create", LoginName["CreateOperationData"]> | OakOperation<BaseLoginName.OpUpdateAction, LoginName["UpdateOperationData"], LoginName["Filter"]>;
|
|
mobile?: OakOperation<"create", Mobile["CreateOperationData"]> | OakOperation<BaseMobile.OpUpdateAction, Mobile["UpdateOperationData"], Mobile["Filter"]>;
|
|
oauthUser?: OakOperation<"create", OauthUser["CreateOperationData"]> | OakOperation<BaseOauthUser.OpUpdateAction, OauthUser["UpdateOperationData"], OauthUser["Filter"]>;
|
|
parasite?: OakOperation<"create", Parasite["CreateOperationData"]> | OakOperation<BaseParasite.OpUpdateAction, Parasite["UpdateOperationData"], Parasite["Filter"]>;
|
|
wechatLogin?: OakOperation<"create", WechatLogin["CreateOperationData"]> | OakOperation<BaseWechatLogin.OpUpdateAction, WechatLogin["UpdateOperationData"], WechatLogin["Filter"]>;
|
|
wechatUser?: OakOperation<"create", WechatUser["CreateOperationData"]> | OakOperation<BaseWechatUser.OpUpdateAction, WechatUser["UpdateOperationData"], WechatUser["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Token["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Token["CreateOperationData"]>>;
|
|
Create: Token["CreateSingle"] | Token["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseToken.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
player?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
email?: OakOperation<"create", Email["CreateOperationData"]> | OakOperation<BaseEmail.OpUpdateAction, Email["UpdateOperationData"], Email["Filter"]> | OakOperation<"remove", Email["RemoveOperationData"], Email["Filter"]>;
|
|
loginName?: OakOperation<"create", LoginName["CreateOperationData"]> | OakOperation<BaseLoginName.OpUpdateAction, LoginName["UpdateOperationData"], LoginName["Filter"]> | OakOperation<"remove", LoginName["RemoveOperationData"], LoginName["Filter"]>;
|
|
mobile?: OakOperation<"create", Mobile["CreateOperationData"]> | OakOperation<BaseMobile.OpUpdateAction, Mobile["UpdateOperationData"], Mobile["Filter"]> | OakOperation<"remove", Mobile["RemoveOperationData"], Mobile["Filter"]>;
|
|
oauthUser?: OakOperation<"create", OauthUser["CreateOperationData"]> | OakOperation<BaseOauthUser.OpUpdateAction, OauthUser["UpdateOperationData"], OauthUser["Filter"]> | OakOperation<"remove", OauthUser["RemoveOperationData"], OauthUser["Filter"]>;
|
|
parasite?: OakOperation<"create", Parasite["CreateOperationData"]> | OakOperation<BaseParasite.OpUpdateAction, Parasite["UpdateOperationData"], Parasite["Filter"]> | OakOperation<"remove", Parasite["RemoveOperationData"], Parasite["Filter"]>;
|
|
wechatLogin?: OakOperation<"create", WechatLogin["CreateOperationData"]> | OakOperation<BaseWechatLogin.OpUpdateAction, WechatLogin["UpdateOperationData"], WechatLogin["Filter"]> | OakOperation<"remove", WechatLogin["RemoveOperationData"], WechatLogin["Filter"]>;
|
|
wechatUser?: OakOperation<"create", WechatUser["CreateOperationData"]> | OakOperation<BaseWechatUser.OpUpdateAction, WechatUser["UpdateOperationData"], WechatUser["Filter"]> | OakOperation<"remove", WechatUser["RemoveOperationData"], WechatUser["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseToken.OpUpdateAction, Token["UpdateOperationData"], Token["Filter"], Token["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"], Token["Sorter"]>;
|
|
Operation: Token["Create"] | Token["Update"] | Token["Remove"];
|
|
};
|
|
export type UserSystem = {
|
|
OpSchema: BaseUserSystem.OpSchema;
|
|
Action: BaseUserSystem.OpAction;
|
|
Schema: BaseUserSystem.OpSchema & {
|
|
user: User["Schema"];
|
|
system: System["Schema"];
|
|
};
|
|
Projection: BaseUserSystem.OpProjection & {
|
|
user?: User["Projection"];
|
|
system?: System["Projection"];
|
|
};
|
|
FilterUnit: BaseUserSystem.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<UserSystem["FilterUnit"]>;
|
|
SortAttr: Partial<BaseUserSystem.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: UserSystem["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: UserSystem["SortNode"][];
|
|
Selection: OakSelection<"select", UserSystem["Projection"], UserSystem["Filter"], UserSystem["Sorter"]>;
|
|
Aggregation: DeduceAggregation<UserSystem["Projection"], UserSystem["Filter"], UserSystem["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseUserSystem.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", UserSystem["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<UserSystem["CreateOperationData"]>>;
|
|
Create: UserSystem["CreateSingle"] | UserSystem["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseUserSystem.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseUserSystem.OpUpdateAction, UserSystem["UpdateOperationData"], UserSystem["Filter"], UserSystem["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", UserSystem["RemoveOperationData"], UserSystem["Filter"], UserSystem["Sorter"]>;
|
|
Operation: UserSystem["Create"] | UserSystem["Update"] | UserSystem["Remove"];
|
|
};
|
|
export type UserWechatPublicTag = {
|
|
OpSchema: BaseUserWechatPublicTag.OpSchema;
|
|
Action: BaseUserWechatPublicTag.OpAction;
|
|
Schema: BaseUserWechatPublicTag.OpSchema & {
|
|
wechatPublicTag: WechatPublicTag["Schema"];
|
|
wechatUser: WechatUser["Schema"];
|
|
};
|
|
Projection: BaseUserWechatPublicTag.OpProjection & {
|
|
wechatPublicTag?: WechatPublicTag["Projection"];
|
|
wechatUser?: WechatUser["Projection"];
|
|
};
|
|
FilterUnit: BaseUserWechatPublicTag.OpFilter & {
|
|
wechatPublicTag: MakeFilter<WechatPublicTag["FilterUnit"]>;
|
|
wechatUser: MakeFilter<WechatUser["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<UserWechatPublicTag["FilterUnit"]>;
|
|
SortAttr: Partial<BaseUserWechatPublicTag.OpSortAttr | {
|
|
wechatPublicTag: WechatPublicTag["SortAttr"];
|
|
wechatUser: WechatUser["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: UserWechatPublicTag["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: UserWechatPublicTag["SortNode"][];
|
|
Selection: OakSelection<"select", UserWechatPublicTag["Projection"], UserWechatPublicTag["Filter"], UserWechatPublicTag["Sorter"]>;
|
|
Aggregation: DeduceAggregation<UserWechatPublicTag["Projection"], UserWechatPublicTag["Filter"], UserWechatPublicTag["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseUserWechatPublicTag.OpSchema & {
|
|
wechatPublicTag?: OakOperation<"create", WechatPublicTag["CreateOperationData"]> | OakOperation<BaseWechatPublicTag.OpUpdateAction, WechatPublicTag["UpdateOperationData"], WechatPublicTag["Filter"]>;
|
|
wechatUser?: OakOperation<"create", WechatUser["CreateOperationData"]> | OakOperation<BaseWechatUser.OpUpdateAction, WechatUser["UpdateOperationData"], WechatUser["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", UserWechatPublicTag["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<UserWechatPublicTag["CreateOperationData"]>>;
|
|
Create: UserWechatPublicTag["CreateSingle"] | UserWechatPublicTag["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseUserWechatPublicTag.OpSchema & {
|
|
wechatPublicTag?: OakOperation<"create", WechatPublicTag["CreateOperationData"]> | OakOperation<BaseWechatPublicTag.OpUpdateAction, WechatPublicTag["UpdateOperationData"], WechatPublicTag["Filter"]> | OakOperation<"remove", WechatPublicTag["RemoveOperationData"], WechatPublicTag["Filter"]>;
|
|
wechatUser?: OakOperation<"create", WechatUser["CreateOperationData"]> | OakOperation<BaseWechatUser.OpUpdateAction, WechatUser["UpdateOperationData"], WechatUser["Filter"]> | OakOperation<"remove", WechatUser["RemoveOperationData"], WechatUser["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseUserWechatPublicTag.OpUpdateAction, UserWechatPublicTag["UpdateOperationData"], UserWechatPublicTag["Filter"], UserWechatPublicTag["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", UserWechatPublicTag["RemoveOperationData"], UserWechatPublicTag["Filter"], UserWechatPublicTag["Sorter"]>;
|
|
Operation: UserWechatPublicTag["Create"] | UserWechatPublicTag["Update"] | UserWechatPublicTag["Remove"];
|
|
};
|
|
export type WechatLogin = {
|
|
OpSchema: BaseWechatLogin.OpSchema;
|
|
Action: BaseWechatLogin.OpAction;
|
|
Schema: BaseWechatLogin.OpSchema & {
|
|
user?: User["Schema"];
|
|
wechatUser?: WechatUser["Schema"];
|
|
token$entity?: Array<Omit<Token["Schema"], "entity">>;
|
|
wechatQrCode$entity?: Array<Omit<WechatQrCode["Schema"], "entity">>;
|
|
token$entity$$aggr?: AggregationResult<Omit<Token["Schema"], "entity">>;
|
|
wechatQrCode$entity$$aggr?: AggregationResult<Omit<WechatQrCode["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseWechatLogin.OpProjection & {
|
|
user?: User["Projection"];
|
|
wechatUser?: WechatUser["Projection"];
|
|
token$entity?: OakSelection<"select", Omit<Token["Projection"], "wechatLogin">, Omit<Token["Filter"], "wechatLogin">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$entity$$aggr?: DeduceAggregation<Omit<Token["Projection"], "wechatLogin">, Omit<Token["Filter"], "wechatLogin">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
wechatQrCode$entity?: OakSelection<"select", Omit<WechatQrCode["Projection"], "wechatLogin">, Omit<WechatQrCode["Filter"], "wechatLogin">, WechatQrCode["Sorter"]> & {
|
|
$entity: "wechatQrCode";
|
|
};
|
|
wechatQrCode$entity$$aggr?: DeduceAggregation<Omit<WechatQrCode["Projection"], "wechatLogin">, Omit<WechatQrCode["Filter"], "wechatLogin">, WechatQrCode["Sorter"]> & {
|
|
$entity: "wechatQrCode";
|
|
};
|
|
};
|
|
FilterUnit: BaseWechatLogin.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
wechatUser: MakeFilter<WechatUser["FilterUnit"]>;
|
|
token$entity: MakeFilter<Omit<Token["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
wechatQrCode$entity: MakeFilter<Omit<WechatQrCode["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WechatLogin["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatLogin.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
wechatUser: WechatUser["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatLogin["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatLogin["SortNode"][];
|
|
Selection: OakSelection<"select", WechatLogin["Projection"], WechatLogin["Filter"], WechatLogin["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatLogin["Projection"], WechatLogin["Filter"], WechatLogin["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatLogin.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
wechatUser?: OakOperation<"create", WechatUser["CreateOperationData"]> | OakOperation<BaseWechatUser.OpUpdateAction, WechatUser["UpdateOperationData"], WechatUser["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "wechatLogin"> | Omit<Token["CreateOperationData"], "wechatLogin">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "wechatLogin">, Token["Filter"]>)[];
|
|
wechatQrCode$entity?: (OakOperation<"create", Omit<WechatQrCode["CreateOperationData"], "wechatLogin"> | Omit<WechatQrCode["CreateOperationData"], "wechatLogin">[]> | OakOperation<BaseWechatQrCode.OpUpdateAction, Omit<WechatQrCode["UpdateOperationData"], "wechatLogin">, WechatQrCode["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatLogin["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatLogin["CreateOperationData"]>>;
|
|
Create: WechatLogin["CreateSingle"] | WechatLogin["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatLogin.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
wechatUser?: OakOperation<"create", WechatUser["CreateOperationData"]> | OakOperation<BaseWechatUser.OpUpdateAction, WechatUser["UpdateOperationData"], WechatUser["Filter"]> | OakOperation<"remove", WechatUser["RemoveOperationData"], WechatUser["Filter"]>;
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "wechatLogin"> | Omit<Token["CreateOperationData"], "wechatLogin">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "wechatLogin">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
wechatQrCode$entity?: (OakOperation<"create", Omit<WechatQrCode["CreateOperationData"], "wechatLogin"> | Omit<WechatQrCode["CreateOperationData"], "wechatLogin">[]> | OakOperation<BaseWechatQrCode.OpUpdateAction, Omit<WechatQrCode["UpdateOperationData"], "wechatLogin">, WechatQrCode["Filter"]> | OakOperation<"remove", WechatQrCode["RemoveOperationData"], WechatQrCode["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWechatLogin.OpUpdateAction, WechatLogin["UpdateOperationData"], WechatLogin["Filter"], WechatLogin["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatLogin["RemoveOperationData"], WechatLogin["Filter"], WechatLogin["Sorter"]>;
|
|
Operation: WechatLogin["Create"] | WechatLogin["Update"] | WechatLogin["Remove"];
|
|
};
|
|
export type WechatMenu = {
|
|
OpSchema: BaseWechatMenu.OpSchema;
|
|
Action: BaseWechatMenu.OpAction;
|
|
Schema: BaseWechatMenu.OpSchema & {
|
|
application: Application["Schema"];
|
|
wechatPublicTag?: WechatPublicTag["Schema"];
|
|
};
|
|
Projection: BaseWechatMenu.OpProjection & {
|
|
application?: Application["Projection"];
|
|
wechatPublicTag?: WechatPublicTag["Projection"];
|
|
};
|
|
FilterUnit: BaseWechatMenu.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
wechatPublicTag: MakeFilter<WechatPublicTag["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<WechatMenu["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatMenu.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
wechatPublicTag: WechatPublicTag["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatMenu["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatMenu["SortNode"][];
|
|
Selection: OakSelection<"select", WechatMenu["Projection"], WechatMenu["Filter"], WechatMenu["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatMenu["Projection"], WechatMenu["Filter"], WechatMenu["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatMenu.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
wechatPublicTag?: OakOperation<"create", WechatPublicTag["CreateOperationData"]> | OakOperation<BaseWechatPublicTag.OpUpdateAction, WechatPublicTag["UpdateOperationData"], WechatPublicTag["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatMenu["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatMenu["CreateOperationData"]>>;
|
|
Create: WechatMenu["CreateSingle"] | WechatMenu["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatMenu.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
wechatPublicTag?: OakOperation<"create", WechatPublicTag["CreateOperationData"]> | OakOperation<BaseWechatPublicTag.OpUpdateAction, WechatPublicTag["UpdateOperationData"], WechatPublicTag["Filter"]> | OakOperation<"remove", WechatPublicTag["RemoveOperationData"], WechatPublicTag["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseWechatMenu.OpUpdateAction, WechatMenu["UpdateOperationData"], WechatMenu["Filter"], WechatMenu["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatMenu["RemoveOperationData"], WechatMenu["Filter"], WechatMenu["Sorter"]>;
|
|
Operation: WechatMenu["Create"] | WechatMenu["Update"] | WechatMenu["Remove"];
|
|
};
|
|
export type WechatMpJump = {
|
|
OpSchema: BaseWechatMpJump.OpSchema;
|
|
Action: BaseWechatMpJump.OpAction;
|
|
Schema: BaseWechatMpJump.OpSchema & {
|
|
message?: Message["Schema"];
|
|
};
|
|
Projection: BaseWechatMpJump.OpProjection & {
|
|
message?: Message["Projection"];
|
|
};
|
|
FilterUnit: BaseWechatMpJump.OpFilter & {
|
|
message: MakeFilter<Message["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<WechatMpJump["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatMpJump.OpSortAttr | {
|
|
message: Message["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatMpJump["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatMpJump["SortNode"][];
|
|
Selection: OakSelection<"select", WechatMpJump["Projection"], WechatMpJump["Filter"], WechatMpJump["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatMpJump["Projection"], WechatMpJump["Filter"], WechatMpJump["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatMpJump.OpSchema & {
|
|
message?: OakOperation<"create", Message["CreateOperationData"]> | OakOperation<BaseMessage.OpUpdateAction, Message["UpdateOperationData"], Message["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatMpJump["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatMpJump["CreateOperationData"]>>;
|
|
Create: WechatMpJump["CreateSingle"] | WechatMpJump["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatMpJump.OpSchema & {
|
|
message?: OakOperation<"create", Message["CreateOperationData"]> | OakOperation<BaseMessage.OpUpdateAction, Message["UpdateOperationData"], Message["Filter"]> | OakOperation<"remove", Message["RemoveOperationData"], Message["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseWechatMpJump.OpUpdateAction, WechatMpJump["UpdateOperationData"], WechatMpJump["Filter"], WechatMpJump["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatMpJump["RemoveOperationData"], WechatMpJump["Filter"], WechatMpJump["Sorter"]>;
|
|
Operation: WechatMpJump["Create"] | WechatMpJump["Update"] | WechatMpJump["Remove"];
|
|
};
|
|
export type WechatPublicAutoReply = {
|
|
OpSchema: BaseWechatPublicAutoReply.OpSchema;
|
|
Action: BaseWechatPublicAutoReply.OpAction;
|
|
Schema: BaseWechatPublicAutoReply.OpSchema & {
|
|
application: Application["Schema"];
|
|
};
|
|
Projection: BaseWechatPublicAutoReply.OpProjection & {
|
|
application?: Application["Projection"];
|
|
};
|
|
FilterUnit: BaseWechatPublicAutoReply.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<WechatPublicAutoReply["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatPublicAutoReply.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatPublicAutoReply["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatPublicAutoReply["SortNode"][];
|
|
Selection: OakSelection<"select", WechatPublicAutoReply["Projection"], WechatPublicAutoReply["Filter"], WechatPublicAutoReply["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatPublicAutoReply["Projection"], WechatPublicAutoReply["Filter"], WechatPublicAutoReply["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatPublicAutoReply.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatPublicAutoReply["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatPublicAutoReply["CreateOperationData"]>>;
|
|
Create: WechatPublicAutoReply["CreateSingle"] | WechatPublicAutoReply["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatPublicAutoReply.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseWechatPublicAutoReply.OpUpdateAction, WechatPublicAutoReply["UpdateOperationData"], WechatPublicAutoReply["Filter"], WechatPublicAutoReply["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatPublicAutoReply["RemoveOperationData"], WechatPublicAutoReply["Filter"], WechatPublicAutoReply["Sorter"]>;
|
|
Operation: WechatPublicAutoReply["Create"] | WechatPublicAutoReply["Update"] | WechatPublicAutoReply["Remove"];
|
|
};
|
|
export type WechatPublicTag = {
|
|
OpSchema: BaseWechatPublicTag.OpSchema;
|
|
Action: BaseWechatPublicTag.OpAction;
|
|
Schema: BaseWechatPublicTag.OpSchema & {
|
|
application: Application["Schema"];
|
|
userWechatPublicTag$wechatPublicTag?: Array<Omit<UserWechatPublicTag["Schema"], "wechatPublicTag">>;
|
|
wechatMenu$wechatPublicTag?: Array<Omit<WechatMenu["Schema"], "wechatPublicTag">>;
|
|
userWechatPublicTag$wechatPublicTag$$aggr?: AggregationResult<Omit<UserWechatPublicTag["Schema"], "wechatPublicTag">>;
|
|
wechatMenu$wechatPublicTag$$aggr?: AggregationResult<Omit<WechatMenu["Schema"], "wechatPublicTag">>;
|
|
};
|
|
Projection: BaseWechatPublicTag.OpProjection & {
|
|
application?: Application["Projection"];
|
|
userWechatPublicTag$wechatPublicTag?: OakSelection<"select", Omit<UserWechatPublicTag["Projection"], "wechatPublicTag">, Omit<UserWechatPublicTag["Filter"], "wechatPublicTag">, UserWechatPublicTag["Sorter"]> & {
|
|
$entity: "userWechatPublicTag";
|
|
};
|
|
userWechatPublicTag$wechatPublicTag$$aggr?: DeduceAggregation<Omit<UserWechatPublicTag["Projection"], "wechatPublicTag">, Omit<UserWechatPublicTag["Filter"], "wechatPublicTag">, UserWechatPublicTag["Sorter"]> & {
|
|
$entity: "userWechatPublicTag";
|
|
};
|
|
wechatMenu$wechatPublicTag?: OakSelection<"select", Omit<WechatMenu["Projection"], "wechatPublicTag">, Omit<WechatMenu["Filter"], "wechatPublicTag">, WechatMenu["Sorter"]> & {
|
|
$entity: "wechatMenu";
|
|
};
|
|
wechatMenu$wechatPublicTag$$aggr?: DeduceAggregation<Omit<WechatMenu["Projection"], "wechatPublicTag">, Omit<WechatMenu["Filter"], "wechatPublicTag">, WechatMenu["Sorter"]> & {
|
|
$entity: "wechatMenu";
|
|
};
|
|
};
|
|
FilterUnit: BaseWechatPublicTag.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
userWechatPublicTag$wechatPublicTag: MakeFilter<Omit<UserWechatPublicTag["FilterUnit"], "wechatPublicTag">> & SubQueryPredicateMetadata;
|
|
wechatMenu$wechatPublicTag: MakeFilter<Omit<WechatMenu["FilterUnit"], "wechatPublicTag">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WechatPublicTag["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatPublicTag.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatPublicTag["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatPublicTag["SortNode"][];
|
|
Selection: OakSelection<"select", WechatPublicTag["Projection"], WechatPublicTag["Filter"], WechatPublicTag["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatPublicTag["Projection"], WechatPublicTag["Filter"], WechatPublicTag["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatPublicTag.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
userWechatPublicTag$wechatPublicTag?: (OakOperation<"create", Omit<UserWechatPublicTag["CreateOperationData"], "wechatPublicTag"> | Omit<UserWechatPublicTag["CreateOperationData"], "wechatPublicTag">[]> | OakOperation<BaseUserWechatPublicTag.OpUpdateAction, Omit<UserWechatPublicTag["UpdateOperationData"], "wechatPublicTag">, UserWechatPublicTag["Filter"]>)[];
|
|
wechatMenu$wechatPublicTag?: (OakOperation<"create", Omit<WechatMenu["CreateOperationData"], "wechatPublicTag"> | Omit<WechatMenu["CreateOperationData"], "wechatPublicTag">[]> | OakOperation<BaseWechatMenu.OpUpdateAction, Omit<WechatMenu["UpdateOperationData"], "wechatPublicTag">, WechatMenu["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatPublicTag["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatPublicTag["CreateOperationData"]>>;
|
|
Create: WechatPublicTag["CreateSingle"] | WechatPublicTag["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatPublicTag.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
userWechatPublicTag$wechatPublicTag?: (OakOperation<"create", Omit<UserWechatPublicTag["CreateOperationData"], "wechatPublicTag"> | Omit<UserWechatPublicTag["CreateOperationData"], "wechatPublicTag">[]> | OakOperation<BaseUserWechatPublicTag.OpUpdateAction, Omit<UserWechatPublicTag["UpdateOperationData"], "wechatPublicTag">, UserWechatPublicTag["Filter"]> | OakOperation<"remove", UserWechatPublicTag["RemoveOperationData"], UserWechatPublicTag["Filter"]>)[];
|
|
wechatMenu$wechatPublicTag?: (OakOperation<"create", Omit<WechatMenu["CreateOperationData"], "wechatPublicTag"> | Omit<WechatMenu["CreateOperationData"], "wechatPublicTag">[]> | OakOperation<BaseWechatMenu.OpUpdateAction, Omit<WechatMenu["UpdateOperationData"], "wechatPublicTag">, WechatMenu["Filter"]> | OakOperation<"remove", WechatMenu["RemoveOperationData"], WechatMenu["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWechatPublicTag.OpUpdateAction, WechatPublicTag["UpdateOperationData"], WechatPublicTag["Filter"], WechatPublicTag["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatPublicTag["RemoveOperationData"], WechatPublicTag["Filter"], WechatPublicTag["Sorter"]>;
|
|
Operation: WechatPublicTag["Create"] | WechatPublicTag["Update"] | WechatPublicTag["Remove"];
|
|
};
|
|
export type WechatQrCode = {
|
|
OpSchema: BaseWechatQrCode.OpSchema;
|
|
Action: BaseWechatQrCode.OpAction;
|
|
Schema: BaseWechatQrCode.OpSchema & {
|
|
application: Application["Schema"];
|
|
user?: User["Schema"];
|
|
userEntityGrant?: UserEntityGrant["Schema"];
|
|
wechatLogin?: WechatLogin["Schema"];
|
|
};
|
|
Projection: BaseWechatQrCode.OpProjection & {
|
|
application?: Application["Projection"];
|
|
user?: User["Projection"];
|
|
userEntityGrant?: UserEntityGrant["Projection"];
|
|
wechatLogin?: WechatLogin["Projection"];
|
|
};
|
|
FilterUnit: BaseWechatQrCode.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
userEntityGrant: MakeFilter<UserEntityGrant["FilterUnit"]>;
|
|
wechatLogin: MakeFilter<WechatLogin["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<WechatQrCode["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatQrCode.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
user: User["SortAttr"];
|
|
userEntityGrant: UserEntityGrant["SortAttr"];
|
|
wechatLogin: WechatLogin["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatQrCode["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatQrCode["SortNode"][];
|
|
Selection: OakSelection<"select", WechatQrCode["Projection"], WechatQrCode["Filter"], WechatQrCode["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatQrCode["Projection"], WechatQrCode["Filter"], WechatQrCode["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatQrCode.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
userEntityGrant?: OakOperation<"create", UserEntityGrant["CreateOperationData"]> | OakOperation<BaseUserEntityGrant.OpUpdateAction, UserEntityGrant["UpdateOperationData"], UserEntityGrant["Filter"]>;
|
|
wechatLogin?: OakOperation<"create", WechatLogin["CreateOperationData"]> | OakOperation<BaseWechatLogin.OpUpdateAction, WechatLogin["UpdateOperationData"], WechatLogin["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatQrCode["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatQrCode["CreateOperationData"]>>;
|
|
Create: WechatQrCode["CreateSingle"] | WechatQrCode["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatQrCode.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
userEntityGrant?: OakOperation<"create", UserEntityGrant["CreateOperationData"]> | OakOperation<BaseUserEntityGrant.OpUpdateAction, UserEntityGrant["UpdateOperationData"], UserEntityGrant["Filter"]> | OakOperation<"remove", UserEntityGrant["RemoveOperationData"], UserEntityGrant["Filter"]>;
|
|
wechatLogin?: OakOperation<"create", WechatLogin["CreateOperationData"]> | OakOperation<BaseWechatLogin.OpUpdateAction, WechatLogin["UpdateOperationData"], WechatLogin["Filter"]> | OakOperation<"remove", WechatLogin["RemoveOperationData"], WechatLogin["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseWechatQrCode.OpUpdateAction, WechatQrCode["UpdateOperationData"], WechatQrCode["Filter"], WechatQrCode["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatQrCode["RemoveOperationData"], WechatQrCode["Filter"], WechatQrCode["Sorter"]>;
|
|
Operation: WechatQrCode["Create"] | WechatQrCode["Update"] | WechatQrCode["Remove"];
|
|
};
|
|
export type WechatTemplate = {
|
|
OpSchema: BaseWechatTemplate.OpSchema;
|
|
Action: BaseWechatTemplate.OpAction;
|
|
Schema: BaseWechatTemplate.OpSchema & {
|
|
application: Application["Schema"];
|
|
messageTypeTemplate$template?: Array<Omit<MessageTypeTemplate["Schema"], "template">>;
|
|
messageTypeTemplate$template$$aggr?: AggregationResult<Omit<MessageTypeTemplate["Schema"], "template">>;
|
|
};
|
|
Projection: BaseWechatTemplate.OpProjection & {
|
|
application?: Application["Projection"];
|
|
messageTypeTemplate$template?: OakSelection<"select", Omit<MessageTypeTemplate["Projection"], "wechatTemplate">, Omit<MessageTypeTemplate["Filter"], "wechatTemplate">, MessageTypeTemplate["Sorter"]> & {
|
|
$entity: "messageTypeTemplate";
|
|
};
|
|
messageTypeTemplate$template$$aggr?: DeduceAggregation<Omit<MessageTypeTemplate["Projection"], "wechatTemplate">, Omit<MessageTypeTemplate["Filter"], "wechatTemplate">, MessageTypeTemplate["Sorter"]> & {
|
|
$entity: "messageTypeTemplate";
|
|
};
|
|
};
|
|
FilterUnit: BaseWechatTemplate.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
messageTypeTemplate$template: MakeFilter<Omit<MessageTypeTemplate["FilterUnit"], "template">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WechatTemplate["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatTemplate.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatTemplate["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatTemplate["SortNode"][];
|
|
Selection: OakSelection<"select", WechatTemplate["Projection"], WechatTemplate["Filter"], WechatTemplate["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatTemplate["Projection"], WechatTemplate["Filter"], WechatTemplate["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatTemplate.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
messageTypeTemplate$template?: (OakOperation<"create", Omit<MessageTypeTemplate["CreateOperationData"], "template"> | Omit<MessageTypeTemplate["CreateOperationData"], "template">[]> | OakOperation<BaseMessageTypeTemplate.OpUpdateAction, Omit<MessageTypeTemplate["UpdateOperationData"], "template">, MessageTypeTemplate["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatTemplate["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatTemplate["CreateOperationData"]>>;
|
|
Create: WechatTemplate["CreateSingle"] | WechatTemplate["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatTemplate.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
messageTypeTemplate$template?: (OakOperation<"create", Omit<MessageTypeTemplate["CreateOperationData"], "template"> | Omit<MessageTypeTemplate["CreateOperationData"], "template">[]> | OakOperation<BaseMessageTypeTemplate.OpUpdateAction, Omit<MessageTypeTemplate["UpdateOperationData"], "template">, MessageTypeTemplate["Filter"]> | OakOperation<"remove", MessageTypeTemplate["RemoveOperationData"], MessageTypeTemplate["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWechatTemplate.OpUpdateAction, WechatTemplate["UpdateOperationData"], WechatTemplate["Filter"], WechatTemplate["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatTemplate["RemoveOperationData"], WechatTemplate["Filter"], WechatTemplate["Sorter"]>;
|
|
Operation: WechatTemplate["Create"] | WechatTemplate["Update"] | WechatTemplate["Remove"];
|
|
};
|
|
export type WechatUser = {
|
|
OpSchema: BaseWechatUser.OpSchema;
|
|
Action: BaseWechatUser.OpAction;
|
|
Schema: BaseWechatUser.OpSchema & {
|
|
user?: User["Schema"];
|
|
application: Application["Schema"];
|
|
sessionMessage$wechatUser?: Array<Omit<SessionMessage["Schema"], "wechatUser">>;
|
|
userWechatPublicTag$wechatUser?: Array<Omit<UserWechatPublicTag["Schema"], "wechatUser">>;
|
|
wechatLogin$wechatUser?: Array<Omit<WechatLogin["Schema"], "wechatUser">>;
|
|
token$entity?: Array<Omit<Token["Schema"], "entity">>;
|
|
sessionMessage$wechatUser$$aggr?: AggregationResult<Omit<SessionMessage["Schema"], "wechatUser">>;
|
|
userWechatPublicTag$wechatUser$$aggr?: AggregationResult<Omit<UserWechatPublicTag["Schema"], "wechatUser">>;
|
|
wechatLogin$wechatUser$$aggr?: AggregationResult<Omit<WechatLogin["Schema"], "wechatUser">>;
|
|
token$entity$$aggr?: AggregationResult<Omit<Token["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseWechatUser.OpProjection & {
|
|
user?: User["Projection"];
|
|
application?: Application["Projection"];
|
|
sessionMessage$wechatUser?: OakSelection<"select", Omit<SessionMessage["Projection"], "wechatUser">, Omit<SessionMessage["Filter"], "wechatUser">, SessionMessage["Sorter"]> & {
|
|
$entity: "sessionMessage";
|
|
};
|
|
sessionMessage$wechatUser$$aggr?: DeduceAggregation<Omit<SessionMessage["Projection"], "wechatUser">, Omit<SessionMessage["Filter"], "wechatUser">, SessionMessage["Sorter"]> & {
|
|
$entity: "sessionMessage";
|
|
};
|
|
userWechatPublicTag$wechatUser?: OakSelection<"select", Omit<UserWechatPublicTag["Projection"], "wechatUser">, Omit<UserWechatPublicTag["Filter"], "wechatUser">, UserWechatPublicTag["Sorter"]> & {
|
|
$entity: "userWechatPublicTag";
|
|
};
|
|
userWechatPublicTag$wechatUser$$aggr?: DeduceAggregation<Omit<UserWechatPublicTag["Projection"], "wechatUser">, Omit<UserWechatPublicTag["Filter"], "wechatUser">, UserWechatPublicTag["Sorter"]> & {
|
|
$entity: "userWechatPublicTag";
|
|
};
|
|
wechatLogin$wechatUser?: OakSelection<"select", Omit<WechatLogin["Projection"], "wechatUser">, Omit<WechatLogin["Filter"], "wechatUser">, WechatLogin["Sorter"]> & {
|
|
$entity: "wechatLogin";
|
|
};
|
|
wechatLogin$wechatUser$$aggr?: DeduceAggregation<Omit<WechatLogin["Projection"], "wechatUser">, Omit<WechatLogin["Filter"], "wechatUser">, WechatLogin["Sorter"]> & {
|
|
$entity: "wechatLogin";
|
|
};
|
|
token$entity?: OakSelection<"select", Omit<Token["Projection"], "wechatUser">, Omit<Token["Filter"], "wechatUser">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
token$entity$$aggr?: DeduceAggregation<Omit<Token["Projection"], "wechatUser">, Omit<Token["Filter"], "wechatUser">, Token["Sorter"]> & {
|
|
$entity: "token";
|
|
};
|
|
};
|
|
FilterUnit: BaseWechatUser.OpFilter & {
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
sessionMessage$wechatUser: MakeFilter<Omit<SessionMessage["FilterUnit"], "wechatUser">> & SubQueryPredicateMetadata;
|
|
userWechatPublicTag$wechatUser: MakeFilter<Omit<UserWechatPublicTag["FilterUnit"], "wechatUser">> & SubQueryPredicateMetadata;
|
|
wechatLogin$wechatUser: MakeFilter<Omit<WechatLogin["FilterUnit"], "wechatUser">> & SubQueryPredicateMetadata;
|
|
token$entity: MakeFilter<Omit<Token["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WechatUser["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatUser.OpSortAttr | {
|
|
user: User["SortAttr"];
|
|
application: Application["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatUser["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatUser["SortNode"][];
|
|
Selection: OakSelection<"select", WechatUser["Projection"], WechatUser["Filter"], WechatUser["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatUser["Projection"], WechatUser["Filter"], WechatUser["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatUser.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
sessionMessage$wechatUser?: (OakOperation<"create", Omit<SessionMessage["CreateOperationData"], "wechatUser"> | Omit<SessionMessage["CreateOperationData"], "wechatUser">[]> | OakOperation<BaseSessionMessage.OpUpdateAction, Omit<SessionMessage["UpdateOperationData"], "wechatUser">, SessionMessage["Filter"]>)[];
|
|
userWechatPublicTag$wechatUser?: (OakOperation<"create", Omit<UserWechatPublicTag["CreateOperationData"], "wechatUser"> | Omit<UserWechatPublicTag["CreateOperationData"], "wechatUser">[]> | OakOperation<BaseUserWechatPublicTag.OpUpdateAction, Omit<UserWechatPublicTag["UpdateOperationData"], "wechatUser">, UserWechatPublicTag["Filter"]>)[];
|
|
wechatLogin$wechatUser?: (OakOperation<"create", Omit<WechatLogin["CreateOperationData"], "wechatUser"> | Omit<WechatLogin["CreateOperationData"], "wechatUser">[]> | OakOperation<BaseWechatLogin.OpUpdateAction, Omit<WechatLogin["UpdateOperationData"], "wechatUser">, WechatLogin["Filter"]>)[];
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "wechatUser"> | Omit<Token["CreateOperationData"], "wechatUser">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "wechatUser">, Token["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatUser["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatUser["CreateOperationData"]>>;
|
|
Create: WechatUser["CreateSingle"] | WechatUser["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatUser.OpSchema & {
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
sessionMessage$wechatUser?: (OakOperation<"create", Omit<SessionMessage["CreateOperationData"], "wechatUser"> | Omit<SessionMessage["CreateOperationData"], "wechatUser">[]> | OakOperation<BaseSessionMessage.OpUpdateAction, Omit<SessionMessage["UpdateOperationData"], "wechatUser">, SessionMessage["Filter"]> | OakOperation<"remove", SessionMessage["RemoveOperationData"], SessionMessage["Filter"]>)[];
|
|
userWechatPublicTag$wechatUser?: (OakOperation<"create", Omit<UserWechatPublicTag["CreateOperationData"], "wechatUser"> | Omit<UserWechatPublicTag["CreateOperationData"], "wechatUser">[]> | OakOperation<BaseUserWechatPublicTag.OpUpdateAction, Omit<UserWechatPublicTag["UpdateOperationData"], "wechatUser">, UserWechatPublicTag["Filter"]> | OakOperation<"remove", UserWechatPublicTag["RemoveOperationData"], UserWechatPublicTag["Filter"]>)[];
|
|
wechatLogin$wechatUser?: (OakOperation<"create", Omit<WechatLogin["CreateOperationData"], "wechatUser"> | Omit<WechatLogin["CreateOperationData"], "wechatUser">[]> | OakOperation<BaseWechatLogin.OpUpdateAction, Omit<WechatLogin["UpdateOperationData"], "wechatUser">, WechatLogin["Filter"]> | OakOperation<"remove", WechatLogin["RemoveOperationData"], WechatLogin["Filter"]>)[];
|
|
token$entity?: (OakOperation<"create", Omit<Token["CreateOperationData"], "wechatUser"> | Omit<Token["CreateOperationData"], "wechatUser">[]> | OakOperation<BaseToken.OpUpdateAction, Omit<Token["UpdateOperationData"], "wechatUser">, Token["Filter"]> | OakOperation<"remove", Token["RemoveOperationData"], Token["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWechatUser.OpUpdateAction, WechatUser["UpdateOperationData"], WechatUser["Filter"], WechatUser["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatUser["RemoveOperationData"], WechatUser["Filter"], WechatUser["Sorter"]>;
|
|
Operation: WechatUser["Create"] | WechatUser["Update"] | WechatUser["Remove"];
|
|
};
|
|
export type AbstractPayAccount = {
|
|
OpSchema: BaseAbstractPayAccount.OpSchema;
|
|
Action: BaseAbstractPayAccount.OpAction;
|
|
Schema: BaseAbstractPayAccount.OpSchema & {
|
|
system: System["Schema"];
|
|
};
|
|
Projection: BaseAbstractPayAccount.OpProjection & {
|
|
system?: System["Projection"];
|
|
};
|
|
FilterUnit: BaseAbstractPayAccount.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<AbstractPayAccount["FilterUnit"]>;
|
|
SortAttr: Partial<BaseAbstractPayAccount.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: AbstractPayAccount["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: AbstractPayAccount["SortNode"][];
|
|
Selection: OakSelection<"select", AbstractPayAccount["Projection"], AbstractPayAccount["Filter"], AbstractPayAccount["Sorter"]>;
|
|
Aggregation: DeduceAggregation<AbstractPayAccount["Projection"], AbstractPayAccount["Filter"], AbstractPayAccount["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseAbstractPayAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", AbstractPayAccount["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<AbstractPayAccount["CreateOperationData"]>>;
|
|
Create: AbstractPayAccount["CreateSingle"] | AbstractPayAccount["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseAbstractPayAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseAbstractPayAccount.OpUpdateAction, AbstractPayAccount["UpdateOperationData"], AbstractPayAccount["Filter"], AbstractPayAccount["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", AbstractPayAccount["RemoveOperationData"], AbstractPayAccount["Filter"], AbstractPayAccount["Sorter"]>;
|
|
Operation: AbstractPayAccount["Create"] | AbstractPayAccount["Update"] | AbstractPayAccount["Remove"];
|
|
};
|
|
export type AbstractPayProduct = {
|
|
OpSchema: BaseAbstractPayProduct.OpSchema;
|
|
Action: BaseAbstractPayProduct.OpAction;
|
|
Schema: BaseAbstractPayProduct.OpSchema & {
|
|
application: Application["Schema"];
|
|
};
|
|
Projection: BaseAbstractPayProduct.OpProjection & {
|
|
application?: Application["Projection"];
|
|
};
|
|
FilterUnit: BaseAbstractPayProduct.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<AbstractPayProduct["FilterUnit"]>;
|
|
SortAttr: Partial<BaseAbstractPayProduct.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: AbstractPayProduct["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: AbstractPayProduct["SortNode"][];
|
|
Selection: OakSelection<"select", AbstractPayProduct["Projection"], AbstractPayProduct["Filter"], AbstractPayProduct["Sorter"]>;
|
|
Aggregation: DeduceAggregation<AbstractPayProduct["Projection"], AbstractPayProduct["Filter"], AbstractPayProduct["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseAbstractPayProduct.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", AbstractPayProduct["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<AbstractPayProduct["CreateOperationData"]>>;
|
|
Create: AbstractPayProduct["CreateSingle"] | AbstractPayProduct["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseAbstractPayProduct.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseAbstractPayProduct.OpUpdateAction, AbstractPayProduct["UpdateOperationData"], AbstractPayProduct["Filter"], AbstractPayProduct["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", AbstractPayProduct["RemoveOperationData"], AbstractPayProduct["Filter"], AbstractPayProduct["Sorter"]>;
|
|
Operation: AbstractPayProduct["Create"] | AbstractPayProduct["Update"] | AbstractPayProduct["Remove"];
|
|
};
|
|
export type AbstractShipAccount = {
|
|
OpSchema: BaseAbstractShipAccount.OpSchema;
|
|
Action: BaseAbstractShipAccount.OpAction;
|
|
Schema: BaseAbstractShipAccount.OpSchema & {
|
|
system: System["Schema"];
|
|
ship$entity?: Array<Omit<Ship["Schema"], "entity">>;
|
|
ship$entity$$aggr?: AggregationResult<Omit<Ship["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseAbstractShipAccount.OpProjection & {
|
|
system?: System["Projection"];
|
|
ship$entity?: OakSelection<"select", Omit<Ship["Projection"], "abstractShipAccount">, Omit<Ship["Filter"], "abstractShipAccount">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
ship$entity$$aggr?: DeduceAggregation<Omit<Ship["Projection"], "abstractShipAccount">, Omit<Ship["Filter"], "abstractShipAccount">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
};
|
|
FilterUnit: BaseAbstractShipAccount.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
ship$entity: MakeFilter<Omit<Ship["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<AbstractShipAccount["FilterUnit"]>;
|
|
SortAttr: Partial<BaseAbstractShipAccount.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: AbstractShipAccount["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: AbstractShipAccount["SortNode"][];
|
|
Selection: OakSelection<"select", AbstractShipAccount["Projection"], AbstractShipAccount["Filter"], AbstractShipAccount["Sorter"]>;
|
|
Aggregation: DeduceAggregation<AbstractShipAccount["Projection"], AbstractShipAccount["Filter"], AbstractShipAccount["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseAbstractShipAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
ship$entity?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "abstractShipAccount"> | Omit<Ship["CreateOperationData"], "abstractShipAccount">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "abstractShipAccount">, Ship["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", AbstractShipAccount["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<AbstractShipAccount["CreateOperationData"]>>;
|
|
Create: AbstractShipAccount["CreateSingle"] | AbstractShipAccount["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseAbstractShipAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
ship$entity?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "abstractShipAccount"> | Omit<Ship["CreateOperationData"], "abstractShipAccount">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "abstractShipAccount">, Ship["Filter"]> | OakOperation<"remove", Ship["RemoveOperationData"], Ship["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseAbstractShipAccount.OpUpdateAction, AbstractShipAccount["UpdateOperationData"], AbstractShipAccount["Filter"], AbstractShipAccount["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", AbstractShipAccount["RemoveOperationData"], AbstractShipAccount["Filter"], AbstractShipAccount["Sorter"]>;
|
|
Operation: AbstractShipAccount["Create"] | AbstractShipAccount["Update"] | AbstractShipAccount["Remove"];
|
|
};
|
|
export type Account = {
|
|
OpSchema: BaseAccount.OpSchema;
|
|
Action: BaseAccount.OpAction;
|
|
Schema: BaseAccount.OpSchema & {
|
|
ofSystem: System["Schema"];
|
|
system?: System["Schema"];
|
|
user?: User["Schema"];
|
|
accountOper$account?: Array<Omit<AccountOper["Schema"], "account">>;
|
|
deposit$account?: Array<Omit<Deposit["Schema"], "account">>;
|
|
settlement$account?: Array<Omit<Settlement["Schema"], "account">>;
|
|
withdraw$account?: Array<Omit<Withdraw["Schema"], "account">>;
|
|
pay$entity?: Array<Omit<Pay["Schema"], "entity">>;
|
|
accountOper$account$$aggr?: AggregationResult<Omit<AccountOper["Schema"], "account">>;
|
|
deposit$account$$aggr?: AggregationResult<Omit<Deposit["Schema"], "account">>;
|
|
settlement$account$$aggr?: AggregationResult<Omit<Settlement["Schema"], "account">>;
|
|
withdraw$account$$aggr?: AggregationResult<Omit<Withdraw["Schema"], "account">>;
|
|
pay$entity$$aggr?: AggregationResult<Omit<Pay["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseAccount.OpProjection & {
|
|
ofSystem?: System["Projection"];
|
|
system?: System["Projection"];
|
|
user?: User["Projection"];
|
|
accountOper$account?: OakSelection<"select", Omit<AccountOper["Projection"], "account">, Omit<AccountOper["Filter"], "account">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
accountOper$account$$aggr?: DeduceAggregation<Omit<AccountOper["Projection"], "account">, Omit<AccountOper["Filter"], "account">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
deposit$account?: OakSelection<"select", Omit<Deposit["Projection"], "account">, Omit<Deposit["Filter"], "account">, Deposit["Sorter"]> & {
|
|
$entity: "deposit";
|
|
};
|
|
deposit$account$$aggr?: DeduceAggregation<Omit<Deposit["Projection"], "account">, Omit<Deposit["Filter"], "account">, Deposit["Sorter"]> & {
|
|
$entity: "deposit";
|
|
};
|
|
settlement$account?: OakSelection<"select", Omit<Settlement["Projection"], "account">, Omit<Settlement["Filter"], "account">, Settlement["Sorter"]> & {
|
|
$entity: "settlement";
|
|
};
|
|
settlement$account$$aggr?: DeduceAggregation<Omit<Settlement["Projection"], "account">, Omit<Settlement["Filter"], "account">, Settlement["Sorter"]> & {
|
|
$entity: "settlement";
|
|
};
|
|
withdraw$account?: OakSelection<"select", Omit<Withdraw["Projection"], "account">, Omit<Withdraw["Filter"], "account">, Withdraw["Sorter"]> & {
|
|
$entity: "withdraw";
|
|
};
|
|
withdraw$account$$aggr?: DeduceAggregation<Omit<Withdraw["Projection"], "account">, Omit<Withdraw["Filter"], "account">, Withdraw["Sorter"]> & {
|
|
$entity: "withdraw";
|
|
};
|
|
pay$entity?: OakSelection<"select", Omit<Pay["Projection"], "account">, Omit<Pay["Filter"], "account">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
pay$entity$$aggr?: DeduceAggregation<Omit<Pay["Projection"], "account">, Omit<Pay["Filter"], "account">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
};
|
|
FilterUnit: BaseAccount.OpFilter & {
|
|
ofSystem: MakeFilter<System["FilterUnit"]>;
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
accountOper$account: MakeFilter<Omit<AccountOper["FilterUnit"], "account">> & SubQueryPredicateMetadata;
|
|
deposit$account: MakeFilter<Omit<Deposit["FilterUnit"], "account">> & SubQueryPredicateMetadata;
|
|
settlement$account: MakeFilter<Omit<Settlement["FilterUnit"], "account">> & SubQueryPredicateMetadata;
|
|
withdraw$account: MakeFilter<Omit<Withdraw["FilterUnit"], "account">> & SubQueryPredicateMetadata;
|
|
pay$entity: MakeFilter<Omit<Pay["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Account["FilterUnit"]>;
|
|
SortAttr: Partial<BaseAccount.OpSortAttr | {
|
|
ofSystem: System["SortAttr"];
|
|
system: System["SortAttr"];
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Account["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Account["SortNode"][];
|
|
Selection: OakSelection<"select", Account["Projection"], Account["Filter"], Account["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Account["Projection"], Account["Filter"], Account["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseAccount.OpSchema & {
|
|
ofSystem?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
accountOper$account?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "account"> | Omit<AccountOper["CreateOperationData"], "account">[]>[];
|
|
deposit$account?: (OakOperation<"create", Omit<Deposit["CreateOperationData"], "account"> | Omit<Deposit["CreateOperationData"], "account">[]> | OakOperation<BaseDeposit.OpUpdateAction, Omit<Deposit["UpdateOperationData"], "account">, Deposit["Filter"]>)[];
|
|
settlement$account?: (OakOperation<"create", Omit<Settlement["CreateOperationData"], "account"> | Omit<Settlement["CreateOperationData"], "account">[]> | OakOperation<BaseSettlement.OpUpdateAction, Omit<Settlement["UpdateOperationData"], "account">, Settlement["Filter"]>)[];
|
|
withdraw$account?: (OakOperation<"create", Omit<Withdraw["CreateOperationData"], "account"> | Omit<Withdraw["CreateOperationData"], "account">[]> | OakOperation<BaseWithdraw.OpUpdateAction, Omit<Withdraw["UpdateOperationData"], "account">, Withdraw["Filter"]>)[];
|
|
pay$entity?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "account"> | Omit<Pay["CreateOperationData"], "account">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "account">, Pay["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Account["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Account["CreateOperationData"]>>;
|
|
Create: Account["CreateSingle"] | Account["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseAccount.OpSchema & {
|
|
ofSystem?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
accountOper$account?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "account"> | Omit<AccountOper["CreateOperationData"], "account">[]>[];
|
|
deposit$account?: (OakOperation<"create", Omit<Deposit["CreateOperationData"], "account"> | Omit<Deposit["CreateOperationData"], "account">[]> | OakOperation<BaseDeposit.OpUpdateAction, Omit<Deposit["UpdateOperationData"], "account">, Deposit["Filter"]> | OakOperation<"remove", Deposit["RemoveOperationData"], Deposit["Filter"]>)[];
|
|
settlement$account?: (OakOperation<"create", Omit<Settlement["CreateOperationData"], "account"> | Omit<Settlement["CreateOperationData"], "account">[]> | OakOperation<BaseSettlement.OpUpdateAction, Omit<Settlement["UpdateOperationData"], "account">, Settlement["Filter"]> | OakOperation<"remove", Settlement["RemoveOperationData"], Settlement["Filter"]>)[];
|
|
withdraw$account?: (OakOperation<"create", Omit<Withdraw["CreateOperationData"], "account"> | Omit<Withdraw["CreateOperationData"], "account">[]> | OakOperation<BaseWithdraw.OpUpdateAction, Omit<Withdraw["UpdateOperationData"], "account">, Withdraw["Filter"]> | OakOperation<"remove", Withdraw["RemoveOperationData"], Withdraw["Filter"]>)[];
|
|
pay$entity?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "account"> | Omit<Pay["CreateOperationData"], "account">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "account">, Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"], Account["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Account["RemoveOperationData"], Account["Filter"], Account["Sorter"]>;
|
|
Operation: Account["Create"] | Account["Update"] | Account["Remove"];
|
|
};
|
|
export type AccountOper = {
|
|
OpSchema: BaseAccountOper.OpSchema;
|
|
Action: BaseAccountOper.OpAction;
|
|
Schema: BaseAccountOper.OpSchema & {
|
|
account: Account["Schema"];
|
|
deposit?: Deposit["Schema"];
|
|
order?: Order["Schema"];
|
|
pay?: Pay["Schema"];
|
|
refund?: Refund["Schema"];
|
|
settlement?: Settlement["Schema"];
|
|
withdraw?: Withdraw["Schema"];
|
|
withdrawTransfer?: WithdrawTransfer["Schema"];
|
|
};
|
|
Projection: BaseAccountOper.OpProjection & {
|
|
account?: Account["Projection"];
|
|
deposit?: Deposit["Projection"];
|
|
order?: Order["Projection"];
|
|
pay?: Pay["Projection"];
|
|
refund?: Refund["Projection"];
|
|
settlement?: Settlement["Projection"];
|
|
withdraw?: Withdraw["Projection"];
|
|
withdrawTransfer?: WithdrawTransfer["Projection"];
|
|
};
|
|
FilterUnit: BaseAccountOper.OpFilter & {
|
|
account: MakeFilter<Account["FilterUnit"]>;
|
|
deposit: MakeFilter<Deposit["FilterUnit"]>;
|
|
order: MakeFilter<Order["FilterUnit"]>;
|
|
pay: MakeFilter<Pay["FilterUnit"]>;
|
|
refund: MakeFilter<Refund["FilterUnit"]>;
|
|
settlement: MakeFilter<Settlement["FilterUnit"]>;
|
|
withdraw: MakeFilter<Withdraw["FilterUnit"]>;
|
|
withdrawTransfer: MakeFilter<WithdrawTransfer["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<AccountOper["FilterUnit"]>;
|
|
SortAttr: Partial<BaseAccountOper.OpSortAttr | {
|
|
account: Account["SortAttr"];
|
|
deposit: Deposit["SortAttr"];
|
|
order: Order["SortAttr"];
|
|
pay: Pay["SortAttr"];
|
|
refund: Refund["SortAttr"];
|
|
settlement: Settlement["SortAttr"];
|
|
withdraw: Withdraw["SortAttr"];
|
|
withdrawTransfer: WithdrawTransfer["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: AccountOper["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: AccountOper["SortNode"][];
|
|
Selection: OakSelection<"select", AccountOper["Projection"], AccountOper["Filter"], AccountOper["Sorter"]>;
|
|
Aggregation: DeduceAggregation<AccountOper["Projection"], AccountOper["Filter"], AccountOper["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseAccountOper.OpSchema & {
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]>;
|
|
deposit?: OakOperation<"create", Deposit["CreateOperationData"]> | OakOperation<BaseDeposit.OpUpdateAction, Deposit["UpdateOperationData"], Deposit["Filter"]>;
|
|
order?: OakOperation<"create", Order["CreateOperationData"]> | OakOperation<BaseOrder.OpUpdateAction, Order["UpdateOperationData"], Order["Filter"]>;
|
|
pay?: OakOperation<"create", Pay["CreateOperationData"]> | OakOperation<BasePay.OpUpdateAction, Pay["UpdateOperationData"], Pay["Filter"]>;
|
|
refund?: OakOperation<"create", Refund["CreateOperationData"]> | OakOperation<BaseRefund.OpUpdateAction, Refund["UpdateOperationData"], Refund["Filter"]>;
|
|
settlement?: OakOperation<"create", Settlement["CreateOperationData"]> | OakOperation<BaseSettlement.OpUpdateAction, Settlement["UpdateOperationData"], Settlement["Filter"]>;
|
|
withdraw?: OakOperation<"create", Withdraw["CreateOperationData"]> | OakOperation<BaseWithdraw.OpUpdateAction, Withdraw["UpdateOperationData"], Withdraw["Filter"]>;
|
|
withdrawTransfer?: OakOperation<"create", WithdrawTransfer["CreateOperationData"]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, WithdrawTransfer["UpdateOperationData"], WithdrawTransfer["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", AccountOper["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<AccountOper["CreateOperationData"]>>;
|
|
Create: AccountOper["CreateSingle"] | AccountOper["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseAccountOper.OpSchema & {
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]> | OakOperation<"remove", Account["RemoveOperationData"], Account["Filter"]>;
|
|
deposit?: OakOperation<"create", Deposit["CreateOperationData"]> | OakOperation<BaseDeposit.OpUpdateAction, Deposit["UpdateOperationData"], Deposit["Filter"]> | OakOperation<"remove", Deposit["RemoveOperationData"], Deposit["Filter"]>;
|
|
order?: OakOperation<"create", Order["CreateOperationData"]> | OakOperation<BaseOrder.OpUpdateAction, Order["UpdateOperationData"], Order["Filter"]> | OakOperation<"remove", Order["RemoveOperationData"], Order["Filter"]>;
|
|
pay?: OakOperation<"create", Pay["CreateOperationData"]> | OakOperation<BasePay.OpUpdateAction, Pay["UpdateOperationData"], Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>;
|
|
refund?: OakOperation<"create", Refund["CreateOperationData"]> | OakOperation<BaseRefund.OpUpdateAction, Refund["UpdateOperationData"], Refund["Filter"]> | OakOperation<"remove", Refund["RemoveOperationData"], Refund["Filter"]>;
|
|
settlement?: OakOperation<"create", Settlement["CreateOperationData"]> | OakOperation<BaseSettlement.OpUpdateAction, Settlement["UpdateOperationData"], Settlement["Filter"]> | OakOperation<"remove", Settlement["RemoveOperationData"], Settlement["Filter"]>;
|
|
withdraw?: OakOperation<"create", Withdraw["CreateOperationData"]> | OakOperation<BaseWithdraw.OpUpdateAction, Withdraw["UpdateOperationData"], Withdraw["Filter"]> | OakOperation<"remove", Withdraw["RemoveOperationData"], Withdraw["Filter"]>;
|
|
withdrawTransfer?: OakOperation<"create", WithdrawTransfer["CreateOperationData"]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, WithdrawTransfer["UpdateOperationData"], WithdrawTransfer["Filter"]> | OakOperation<"remove", WithdrawTransfer["RemoveOperationData"], WithdrawTransfer["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseAccountOper.OpUpdateAction, AccountOper["UpdateOperationData"], AccountOper["Filter"], AccountOper["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", AccountOper["RemoveOperationData"], AccountOper["Filter"], AccountOper["Sorter"]>;
|
|
Operation: AccountOper["Create"] | AccountOper["Update"] | AccountOper["Remove"];
|
|
};
|
|
export type AliPay = {
|
|
OpSchema: BaseAliPay.OpSchema;
|
|
Action: BaseAliPay.OpAction;
|
|
Schema: BaseAliPay.OpSchema & {
|
|
system: System["Schema"];
|
|
apAccount$aliPay?: Array<Omit<ApAccount["Schema"], "aliPay">>;
|
|
apAccount$aliPay$$aggr?: AggregationResult<Omit<ApAccount["Schema"], "aliPay">>;
|
|
};
|
|
Projection: BaseAliPay.OpProjection & {
|
|
system?: System["Projection"];
|
|
apAccount$aliPay?: OakSelection<"select", Omit<ApAccount["Projection"], "aliPay">, Omit<ApAccount["Filter"], "aliPay">, ApAccount["Sorter"]> & {
|
|
$entity: "apAccount";
|
|
};
|
|
apAccount$aliPay$$aggr?: DeduceAggregation<Omit<ApAccount["Projection"], "aliPay">, Omit<ApAccount["Filter"], "aliPay">, ApAccount["Sorter"]> & {
|
|
$entity: "apAccount";
|
|
};
|
|
};
|
|
FilterUnit: BaseAliPay.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
apAccount$aliPay: MakeFilter<Omit<ApAccount["FilterUnit"], "aliPay">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<AliPay["FilterUnit"]>;
|
|
SortAttr: Partial<BaseAliPay.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: AliPay["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: AliPay["SortNode"][];
|
|
Selection: OakSelection<"select", AliPay["Projection"], AliPay["Filter"], AliPay["Sorter"]>;
|
|
Aggregation: DeduceAggregation<AliPay["Projection"], AliPay["Filter"], AliPay["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseAliPay.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
apAccount$aliPay?: (OakOperation<"create", Omit<ApAccount["CreateOperationData"], "aliPay"> | Omit<ApAccount["CreateOperationData"], "aliPay">[]> | OakOperation<BaseApAccount.OpUpdateAction, Omit<ApAccount["UpdateOperationData"], "aliPay">, ApAccount["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", AliPay["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<AliPay["CreateOperationData"]>>;
|
|
Create: AliPay["CreateSingle"] | AliPay["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseAliPay.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
apAccount$aliPay?: (OakOperation<"create", Omit<ApAccount["CreateOperationData"], "aliPay"> | Omit<ApAccount["CreateOperationData"], "aliPay">[]> | OakOperation<BaseApAccount.OpUpdateAction, Omit<ApAccount["UpdateOperationData"], "aliPay">, ApAccount["Filter"]> | OakOperation<"remove", ApAccount["RemoveOperationData"], ApAccount["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseAliPay.OpUpdateAction, AliPay["UpdateOperationData"], AliPay["Filter"], AliPay["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", AliPay["RemoveOperationData"], AliPay["Filter"], AliPay["Sorter"]>;
|
|
Operation: AliPay["Create"] | AliPay["Update"] | AliPay["Remove"];
|
|
};
|
|
export type ApAccount = {
|
|
OpSchema: BaseApAccount.OpSchema;
|
|
Action: BaseApAccount.OpAction;
|
|
Schema: BaseApAccount.OpSchema & {
|
|
system: System["Schema"];
|
|
aliPay: AliPay["Schema"];
|
|
apProduct$apAccount?: Array<Omit<ApProduct["Schema"], "apAccount">>;
|
|
sysAccountOper$entity?: Array<Omit<SysAccountOper["Schema"], "entity">>;
|
|
withdrawChannel$entity?: Array<Omit<WithdrawChannel["Schema"], "entity">>;
|
|
apProduct$apAccount$$aggr?: AggregationResult<Omit<ApProduct["Schema"], "apAccount">>;
|
|
sysAccountOper$entity$$aggr?: AggregationResult<Omit<SysAccountOper["Schema"], "entity">>;
|
|
withdrawChannel$entity$$aggr?: AggregationResult<Omit<WithdrawChannel["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseApAccount.OpProjection & {
|
|
system?: System["Projection"];
|
|
aliPay?: AliPay["Projection"];
|
|
apProduct$apAccount?: OakSelection<"select", Omit<ApProduct["Projection"], "apAccount">, Omit<ApProduct["Filter"], "apAccount">, ApProduct["Sorter"]> & {
|
|
$entity: "apProduct";
|
|
};
|
|
apProduct$apAccount$$aggr?: DeduceAggregation<Omit<ApProduct["Projection"], "apAccount">, Omit<ApProduct["Filter"], "apAccount">, ApProduct["Sorter"]> & {
|
|
$entity: "apProduct";
|
|
};
|
|
sysAccountOper$entity?: OakSelection<"select", Omit<SysAccountOper["Projection"], "apAccount">, Omit<SysAccountOper["Filter"], "apAccount">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
sysAccountOper$entity$$aggr?: DeduceAggregation<Omit<SysAccountOper["Projection"], "apAccount">, Omit<SysAccountOper["Filter"], "apAccount">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
withdrawChannel$entity?: OakSelection<"select", Omit<WithdrawChannel["Projection"], "apAccount">, Omit<WithdrawChannel["Filter"], "apAccount">, WithdrawChannel["Sorter"]> & {
|
|
$entity: "withdrawChannel";
|
|
};
|
|
withdrawChannel$entity$$aggr?: DeduceAggregation<Omit<WithdrawChannel["Projection"], "apAccount">, Omit<WithdrawChannel["Filter"], "apAccount">, WithdrawChannel["Sorter"]> & {
|
|
$entity: "withdrawChannel";
|
|
};
|
|
};
|
|
FilterUnit: BaseApAccount.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
aliPay: MakeFilter<AliPay["FilterUnit"]>;
|
|
apProduct$apAccount: MakeFilter<Omit<ApProduct["FilterUnit"], "apAccount">> & SubQueryPredicateMetadata;
|
|
sysAccountOper$entity: MakeFilter<Omit<SysAccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
withdrawChannel$entity: MakeFilter<Omit<WithdrawChannel["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<ApAccount["FilterUnit"]>;
|
|
SortAttr: Partial<BaseApAccount.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
aliPay: AliPay["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ApAccount["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ApAccount["SortNode"][];
|
|
Selection: OakSelection<"select", ApAccount["Projection"], ApAccount["Filter"], ApAccount["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ApAccount["Projection"], ApAccount["Filter"], ApAccount["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseApAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
aliPay?: OakOperation<"create", AliPay["CreateOperationData"]> | OakOperation<BaseAliPay.OpUpdateAction, AliPay["UpdateOperationData"], AliPay["Filter"]>;
|
|
apProduct$apAccount?: (OakOperation<"create", Omit<ApProduct["CreateOperationData"], "apAccount"> | Omit<ApProduct["CreateOperationData"], "apAccount">[]> | OakOperation<BaseApProduct.OpUpdateAction, Omit<ApProduct["UpdateOperationData"], "apAccount">, ApProduct["Filter"]>)[];
|
|
sysAccountOper$entity?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "apAccount"> | Omit<SysAccountOper["CreateOperationData"], "apAccount">[]>[];
|
|
withdrawChannel$entity?: (OakOperation<"create", Omit<WithdrawChannel["CreateOperationData"], "apAccount"> | Omit<WithdrawChannel["CreateOperationData"], "apAccount">[]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, Omit<WithdrawChannel["UpdateOperationData"], "apAccount">, WithdrawChannel["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ApAccount["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ApAccount["CreateOperationData"]>>;
|
|
Create: ApAccount["CreateSingle"] | ApAccount["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseApAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
aliPay?: OakOperation<"create", AliPay["CreateOperationData"]> | OakOperation<BaseAliPay.OpUpdateAction, AliPay["UpdateOperationData"], AliPay["Filter"]> | OakOperation<"remove", AliPay["RemoveOperationData"], AliPay["Filter"]>;
|
|
apProduct$apAccount?: (OakOperation<"create", Omit<ApProduct["CreateOperationData"], "apAccount"> | Omit<ApProduct["CreateOperationData"], "apAccount">[]> | OakOperation<BaseApProduct.OpUpdateAction, Omit<ApProduct["UpdateOperationData"], "apAccount">, ApProduct["Filter"]> | OakOperation<"remove", ApProduct["RemoveOperationData"], ApProduct["Filter"]>)[];
|
|
sysAccountOper$entity?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "apAccount"> | Omit<SysAccountOper["CreateOperationData"], "apAccount">[]>[];
|
|
withdrawChannel$entity?: (OakOperation<"create", Omit<WithdrawChannel["CreateOperationData"], "apAccount"> | Omit<WithdrawChannel["CreateOperationData"], "apAccount">[]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, Omit<WithdrawChannel["UpdateOperationData"], "apAccount">, WithdrawChannel["Filter"]> | OakOperation<"remove", WithdrawChannel["RemoveOperationData"], WithdrawChannel["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseApAccount.OpUpdateAction, ApAccount["UpdateOperationData"], ApAccount["Filter"], ApAccount["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ApAccount["RemoveOperationData"], ApAccount["Filter"], ApAccount["Sorter"]>;
|
|
Operation: ApAccount["Create"] | ApAccount["Update"] | ApAccount["Remove"];
|
|
};
|
|
export type ApProduct = {
|
|
OpSchema: BaseApProduct.OpSchema;
|
|
Action: BaseApProduct.OpAction;
|
|
Schema: BaseApProduct.OpSchema & {
|
|
application: Application["Schema"];
|
|
apAccount: ApAccount["Schema"];
|
|
pay$entity?: Array<Omit<Pay["Schema"], "entity">>;
|
|
pay$entity$$aggr?: AggregationResult<Omit<Pay["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseApProduct.OpProjection & {
|
|
application?: Application["Projection"];
|
|
apAccount?: ApAccount["Projection"];
|
|
pay$entity?: OakSelection<"select", Omit<Pay["Projection"], "apProduct">, Omit<Pay["Filter"], "apProduct">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
pay$entity$$aggr?: DeduceAggregation<Omit<Pay["Projection"], "apProduct">, Omit<Pay["Filter"], "apProduct">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
};
|
|
FilterUnit: BaseApProduct.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
apAccount: MakeFilter<ApAccount["FilterUnit"]>;
|
|
pay$entity: MakeFilter<Omit<Pay["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<ApProduct["FilterUnit"]>;
|
|
SortAttr: Partial<BaseApProduct.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
apAccount: ApAccount["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ApProduct["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ApProduct["SortNode"][];
|
|
Selection: OakSelection<"select", ApProduct["Projection"], ApProduct["Filter"], ApProduct["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ApProduct["Projection"], ApProduct["Filter"], ApProduct["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseApProduct.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
apAccount?: OakOperation<"create", ApAccount["CreateOperationData"]> | OakOperation<BaseApAccount.OpUpdateAction, ApAccount["UpdateOperationData"], ApAccount["Filter"]>;
|
|
pay$entity?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "apProduct"> | Omit<Pay["CreateOperationData"], "apProduct">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "apProduct">, Pay["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ApProduct["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ApProduct["CreateOperationData"]>>;
|
|
Create: ApProduct["CreateSingle"] | ApProduct["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseApProduct.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
apAccount?: OakOperation<"create", ApAccount["CreateOperationData"]> | OakOperation<BaseApAccount.OpUpdateAction, ApAccount["UpdateOperationData"], ApAccount["Filter"]> | OakOperation<"remove", ApAccount["RemoveOperationData"], ApAccount["Filter"]>;
|
|
pay$entity?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "apProduct"> | Omit<Pay["CreateOperationData"], "apProduct">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "apProduct">, Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseApProduct.OpUpdateAction, ApProduct["UpdateOperationData"], ApProduct["Filter"], ApProduct["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ApProduct["RemoveOperationData"], ApProduct["Filter"], ApProduct["Sorter"]>;
|
|
Operation: ApProduct["Create"] | ApProduct["Update"] | ApProduct["Remove"];
|
|
};
|
|
export type Deposit = {
|
|
OpSchema: BaseDeposit.OpSchema;
|
|
Action: BaseDeposit.OpAction;
|
|
Schema: BaseDeposit.OpSchema & {
|
|
account: Account["Schema"];
|
|
creator: User["Schema"];
|
|
ship?: Ship["Schema"];
|
|
pay$deposit?: Array<Omit<Pay["Schema"], "deposit">>;
|
|
accountOper$entity?: Array<Omit<AccountOper["Schema"], "entity">>;
|
|
pay$deposit$$aggr?: AggregationResult<Omit<Pay["Schema"], "deposit">>;
|
|
accountOper$entity$$aggr?: AggregationResult<Omit<AccountOper["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseDeposit.OpProjection & {
|
|
account?: Account["Projection"];
|
|
creator?: User["Projection"];
|
|
ship?: Ship["Projection"];
|
|
pay$deposit?: OakSelection<"select", Omit<Pay["Projection"], "deposit">, Omit<Pay["Filter"], "deposit">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
pay$deposit$$aggr?: DeduceAggregation<Omit<Pay["Projection"], "deposit">, Omit<Pay["Filter"], "deposit">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
accountOper$entity?: OakSelection<"select", Omit<AccountOper["Projection"], "deposit">, Omit<AccountOper["Filter"], "deposit">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
accountOper$entity$$aggr?: DeduceAggregation<Omit<AccountOper["Projection"], "deposit">, Omit<AccountOper["Filter"], "deposit">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
};
|
|
FilterUnit: BaseDeposit.OpFilter & {
|
|
account: MakeFilter<Account["FilterUnit"]>;
|
|
creator: MakeFilter<User["FilterUnit"]>;
|
|
ship: MakeFilter<Ship["FilterUnit"]>;
|
|
pay$deposit: MakeFilter<Omit<Pay["FilterUnit"], "deposit">> & SubQueryPredicateMetadata;
|
|
accountOper$entity: MakeFilter<Omit<AccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Deposit["FilterUnit"]>;
|
|
SortAttr: Partial<BaseDeposit.OpSortAttr | {
|
|
account: Account["SortAttr"];
|
|
creator: User["SortAttr"];
|
|
ship: Ship["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Deposit["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Deposit["SortNode"][];
|
|
Selection: OakSelection<"select", Deposit["Projection"], Deposit["Filter"], Deposit["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Deposit["Projection"], Deposit["Filter"], Deposit["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseDeposit.OpSchema & {
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
ship?: OakOperation<"create", Ship["CreateOperationData"]> | OakOperation<BaseShip.OpUpdateAction, Ship["UpdateOperationData"], Ship["Filter"]>;
|
|
pay$deposit?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "deposit"> | Omit<Pay["CreateOperationData"], "deposit">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "deposit">, Pay["Filter"]>)[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "deposit"> | Omit<AccountOper["CreateOperationData"], "deposit">[]>[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Deposit["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Deposit["CreateOperationData"]>>;
|
|
Create: Deposit["CreateSingle"] | Deposit["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseDeposit.OpSchema & {
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]> | OakOperation<"remove", Account["RemoveOperationData"], Account["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
ship?: OakOperation<"create", Ship["CreateOperationData"]> | OakOperation<BaseShip.OpUpdateAction, Ship["UpdateOperationData"], Ship["Filter"]> | OakOperation<"remove", Ship["RemoveOperationData"], Ship["Filter"]>;
|
|
pay$deposit?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "deposit"> | Omit<Pay["CreateOperationData"], "deposit">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "deposit">, Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>)[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "deposit"> | Omit<AccountOper["CreateOperationData"], "deposit">[]>[];
|
|
}>;
|
|
Update: OakOperation<BaseDeposit.OpUpdateAction, Deposit["UpdateOperationData"], Deposit["Filter"], Deposit["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Deposit["RemoveOperationData"], Deposit["Filter"], Deposit["Sorter"]>;
|
|
Operation: Deposit["Create"] | Deposit["Update"] | Deposit["Remove"];
|
|
};
|
|
export type OfflineAccount = {
|
|
OpSchema: BaseOfflineAccount.OpSchema;
|
|
Action: BaseOfflineAccount.OpAction;
|
|
Schema: BaseOfflineAccount.OpSchema & {
|
|
system: System["Schema"];
|
|
pay$entity?: Array<Omit<Pay["Schema"], "entity">>;
|
|
sysAccountOper$entity?: Array<Omit<SysAccountOper["Schema"], "entity">>;
|
|
withdrawChannel$entity?: Array<Omit<WithdrawChannel["Schema"], "entity">>;
|
|
pay$entity$$aggr?: AggregationResult<Omit<Pay["Schema"], "entity">>;
|
|
sysAccountOper$entity$$aggr?: AggregationResult<Omit<SysAccountOper["Schema"], "entity">>;
|
|
withdrawChannel$entity$$aggr?: AggregationResult<Omit<WithdrawChannel["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseOfflineAccount.OpProjection & {
|
|
system?: System["Projection"];
|
|
pay$entity?: OakSelection<"select", Omit<Pay["Projection"], "offlineAccount">, Omit<Pay["Filter"], "offlineAccount">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
pay$entity$$aggr?: DeduceAggregation<Omit<Pay["Projection"], "offlineAccount">, Omit<Pay["Filter"], "offlineAccount">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
sysAccountOper$entity?: OakSelection<"select", Omit<SysAccountOper["Projection"], "offlineAccount">, Omit<SysAccountOper["Filter"], "offlineAccount">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
sysAccountOper$entity$$aggr?: DeduceAggregation<Omit<SysAccountOper["Projection"], "offlineAccount">, Omit<SysAccountOper["Filter"], "offlineAccount">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
withdrawChannel$entity?: OakSelection<"select", Omit<WithdrawChannel["Projection"], "offlineAccount">, Omit<WithdrawChannel["Filter"], "offlineAccount">, WithdrawChannel["Sorter"]> & {
|
|
$entity: "withdrawChannel";
|
|
};
|
|
withdrawChannel$entity$$aggr?: DeduceAggregation<Omit<WithdrawChannel["Projection"], "offlineAccount">, Omit<WithdrawChannel["Filter"], "offlineAccount">, WithdrawChannel["Sorter"]> & {
|
|
$entity: "withdrawChannel";
|
|
};
|
|
};
|
|
FilterUnit: BaseOfflineAccount.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
pay$entity: MakeFilter<Omit<Pay["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
sysAccountOper$entity: MakeFilter<Omit<SysAccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
withdrawChannel$entity: MakeFilter<Omit<WithdrawChannel["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<OfflineAccount["FilterUnit"]>;
|
|
SortAttr: Partial<BaseOfflineAccount.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: OfflineAccount["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: OfflineAccount["SortNode"][];
|
|
Selection: OakSelection<"select", OfflineAccount["Projection"], OfflineAccount["Filter"], OfflineAccount["Sorter"]>;
|
|
Aggregation: DeduceAggregation<OfflineAccount["Projection"], OfflineAccount["Filter"], OfflineAccount["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseOfflineAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
pay$entity?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "offlineAccount"> | Omit<Pay["CreateOperationData"], "offlineAccount">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "offlineAccount">, Pay["Filter"]>)[];
|
|
sysAccountOper$entity?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "offlineAccount"> | Omit<SysAccountOper["CreateOperationData"], "offlineAccount">[]>[];
|
|
withdrawChannel$entity?: (OakOperation<"create", Omit<WithdrawChannel["CreateOperationData"], "offlineAccount"> | Omit<WithdrawChannel["CreateOperationData"], "offlineAccount">[]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, Omit<WithdrawChannel["UpdateOperationData"], "offlineAccount">, WithdrawChannel["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", OfflineAccount["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<OfflineAccount["CreateOperationData"]>>;
|
|
Create: OfflineAccount["CreateSingle"] | OfflineAccount["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseOfflineAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
pay$entity?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "offlineAccount"> | Omit<Pay["CreateOperationData"], "offlineAccount">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "offlineAccount">, Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>)[];
|
|
sysAccountOper$entity?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "offlineAccount"> | Omit<SysAccountOper["CreateOperationData"], "offlineAccount">[]>[];
|
|
withdrawChannel$entity?: (OakOperation<"create", Omit<WithdrawChannel["CreateOperationData"], "offlineAccount"> | Omit<WithdrawChannel["CreateOperationData"], "offlineAccount">[]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, Omit<WithdrawChannel["UpdateOperationData"], "offlineAccount">, WithdrawChannel["Filter"]> | OakOperation<"remove", WithdrawChannel["RemoveOperationData"], WithdrawChannel["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseOfflineAccount.OpUpdateAction, OfflineAccount["UpdateOperationData"], OfflineAccount["Filter"], OfflineAccount["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", OfflineAccount["RemoveOperationData"], OfflineAccount["Filter"], OfflineAccount["Sorter"]>;
|
|
Operation: OfflineAccount["Create"] | OfflineAccount["Update"] | OfflineAccount["Remove"];
|
|
};
|
|
export type Order = {
|
|
OpSchema: BaseOrder.OpSchema;
|
|
Action: BaseOrder.OpAction;
|
|
Schema: BaseOrder.OpSchema & {
|
|
creator: User["Schema"];
|
|
system: System["Schema"];
|
|
address?: Address["Schema"];
|
|
pay$order?: Array<Omit<Pay["Schema"], "order">>;
|
|
settlePlan$order?: Array<Omit<SettlePlan["Schema"], "order">>;
|
|
shipOrder$order?: Array<Omit<ShipOrder["Schema"], "order">>;
|
|
accountOper$entity?: Array<Omit<AccountOper["Schema"], "entity">>;
|
|
pay$order$$aggr?: AggregationResult<Omit<Pay["Schema"], "order">>;
|
|
settlePlan$order$$aggr?: AggregationResult<Omit<SettlePlan["Schema"], "order">>;
|
|
shipOrder$order$$aggr?: AggregationResult<Omit<ShipOrder["Schema"], "order">>;
|
|
accountOper$entity$$aggr?: AggregationResult<Omit<AccountOper["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseOrder.OpProjection & {
|
|
creator?: User["Projection"];
|
|
system?: System["Projection"];
|
|
address?: Address["Projection"];
|
|
pay$order?: OakSelection<"select", Omit<Pay["Projection"], "order">, Omit<Pay["Filter"], "order">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
pay$order$$aggr?: DeduceAggregation<Omit<Pay["Projection"], "order">, Omit<Pay["Filter"], "order">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
settlePlan$order?: OakSelection<"select", Omit<SettlePlan["Projection"], "order">, Omit<SettlePlan["Filter"], "order">, SettlePlan["Sorter"]> & {
|
|
$entity: "settlePlan";
|
|
};
|
|
settlePlan$order$$aggr?: DeduceAggregation<Omit<SettlePlan["Projection"], "order">, Omit<SettlePlan["Filter"], "order">, SettlePlan["Sorter"]> & {
|
|
$entity: "settlePlan";
|
|
};
|
|
shipOrder$order?: OakSelection<"select", Omit<ShipOrder["Projection"], "order">, Omit<ShipOrder["Filter"], "order">, ShipOrder["Sorter"]> & {
|
|
$entity: "shipOrder";
|
|
};
|
|
shipOrder$order$$aggr?: DeduceAggregation<Omit<ShipOrder["Projection"], "order">, Omit<ShipOrder["Filter"], "order">, ShipOrder["Sorter"]> & {
|
|
$entity: "shipOrder";
|
|
};
|
|
accountOper$entity?: OakSelection<"select", Omit<AccountOper["Projection"], "order">, Omit<AccountOper["Filter"], "order">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
accountOper$entity$$aggr?: DeduceAggregation<Omit<AccountOper["Projection"], "order">, Omit<AccountOper["Filter"], "order">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
};
|
|
FilterUnit: BaseOrder.OpFilter & {
|
|
creator: MakeFilter<User["FilterUnit"]>;
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
address: MakeFilter<Address["FilterUnit"]>;
|
|
pay$order: MakeFilter<Omit<Pay["FilterUnit"], "order">> & SubQueryPredicateMetadata;
|
|
settlePlan$order: MakeFilter<Omit<SettlePlan["FilterUnit"], "order">> & SubQueryPredicateMetadata;
|
|
shipOrder$order: MakeFilter<Omit<ShipOrder["FilterUnit"], "order">> & SubQueryPredicateMetadata;
|
|
accountOper$entity: MakeFilter<Omit<AccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Order["FilterUnit"]>;
|
|
SortAttr: Partial<BaseOrder.OpSortAttr | {
|
|
creator: User["SortAttr"];
|
|
system: System["SortAttr"];
|
|
address: Address["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Order["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Order["SortNode"][];
|
|
Selection: OakSelection<"select", Order["Projection"], Order["Filter"], Order["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Order["Projection"], Order["Filter"], Order["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseOrder.OpSchema & {
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
address?: OakOperation<"create", Address["CreateOperationData"]> | OakOperation<BaseAddress.OpUpdateAction, Address["UpdateOperationData"], Address["Filter"]>;
|
|
pay$order?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "order"> | Omit<Pay["CreateOperationData"], "order">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "order">, Pay["Filter"]>)[];
|
|
settlePlan$order?: (OakOperation<"create", Omit<SettlePlan["CreateOperationData"], "order"> | Omit<SettlePlan["CreateOperationData"], "order">[]> | OakOperation<BaseSettlePlan.OpUpdateAction, Omit<SettlePlan["UpdateOperationData"], "order">, SettlePlan["Filter"]>)[];
|
|
shipOrder$order?: (OakOperation<"create", Omit<ShipOrder["CreateOperationData"], "order"> | Omit<ShipOrder["CreateOperationData"], "order">[]> | OakOperation<BaseShipOrder.OpUpdateAction, Omit<ShipOrder["UpdateOperationData"], "order">, ShipOrder["Filter"]>)[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "order"> | Omit<AccountOper["CreateOperationData"], "order">[]>[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Order["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Order["CreateOperationData"]>>;
|
|
Create: Order["CreateSingle"] | Order["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseOrder.OpSchema & {
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
address?: OakOperation<"create", Address["CreateOperationData"]> | OakOperation<BaseAddress.OpUpdateAction, Address["UpdateOperationData"], Address["Filter"]> | OakOperation<"remove", Address["RemoveOperationData"], Address["Filter"]>;
|
|
pay$order?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "order"> | Omit<Pay["CreateOperationData"], "order">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "order">, Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>)[];
|
|
settlePlan$order?: (OakOperation<"create", Omit<SettlePlan["CreateOperationData"], "order"> | Omit<SettlePlan["CreateOperationData"], "order">[]> | OakOperation<BaseSettlePlan.OpUpdateAction, Omit<SettlePlan["UpdateOperationData"], "order">, SettlePlan["Filter"]> | OakOperation<"remove", SettlePlan["RemoveOperationData"], SettlePlan["Filter"]>)[];
|
|
shipOrder$order?: (OakOperation<"create", Omit<ShipOrder["CreateOperationData"], "order"> | Omit<ShipOrder["CreateOperationData"], "order">[]> | OakOperation<BaseShipOrder.OpUpdateAction, Omit<ShipOrder["UpdateOperationData"], "order">, ShipOrder["Filter"]> | OakOperation<"remove", ShipOrder["RemoveOperationData"], ShipOrder["Filter"]>)[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "order"> | Omit<AccountOper["CreateOperationData"], "order">[]>[];
|
|
}>;
|
|
Update: OakOperation<BaseOrder.OpUpdateAction, Order["UpdateOperationData"], Order["Filter"], Order["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Order["RemoveOperationData"], Order["Filter"], Order["Sorter"]>;
|
|
Operation: Order["Create"] | Order["Update"] | Order["Remove"];
|
|
};
|
|
export type Pay = {
|
|
OpSchema: BasePay.OpSchema;
|
|
Action: BasePay.OpAction;
|
|
Schema: BasePay.OpSchema & {
|
|
deposit?: Deposit["Schema"];
|
|
order?: Order["Schema"];
|
|
application: Application["Schema"];
|
|
creator: User["Schema"];
|
|
account?: Account["Schema"];
|
|
apProduct?: ApProduct["Schema"];
|
|
offlineAccount?: OfflineAccount["Schema"];
|
|
wpProduct?: WpProduct["Schema"];
|
|
refund$pay?: Array<Omit<Refund["Schema"], "pay">>;
|
|
sysAccountOper$pay?: Array<Omit<SysAccountOper["Schema"], "pay">>;
|
|
accountOper$entity?: Array<Omit<AccountOper["Schema"], "entity">>;
|
|
refund$pay$$aggr?: AggregationResult<Omit<Refund["Schema"], "pay">>;
|
|
sysAccountOper$pay$$aggr?: AggregationResult<Omit<SysAccountOper["Schema"], "pay">>;
|
|
accountOper$entity$$aggr?: AggregationResult<Omit<AccountOper["Schema"], "entity">>;
|
|
};
|
|
Projection: BasePay.OpProjection & {
|
|
deposit?: Deposit["Projection"];
|
|
order?: Order["Projection"];
|
|
application?: Application["Projection"];
|
|
creator?: User["Projection"];
|
|
account?: Account["Projection"];
|
|
apProduct?: ApProduct["Projection"];
|
|
offlineAccount?: OfflineAccount["Projection"];
|
|
wpProduct?: WpProduct["Projection"];
|
|
refund$pay?: OakSelection<"select", Omit<Refund["Projection"], "pay">, Omit<Refund["Filter"], "pay">, Refund["Sorter"]> & {
|
|
$entity: "refund";
|
|
};
|
|
refund$pay$$aggr?: DeduceAggregation<Omit<Refund["Projection"], "pay">, Omit<Refund["Filter"], "pay">, Refund["Sorter"]> & {
|
|
$entity: "refund";
|
|
};
|
|
sysAccountOper$pay?: OakSelection<"select", Omit<SysAccountOper["Projection"], "pay">, Omit<SysAccountOper["Filter"], "pay">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
sysAccountOper$pay$$aggr?: DeduceAggregation<Omit<SysAccountOper["Projection"], "pay">, Omit<SysAccountOper["Filter"], "pay">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
accountOper$entity?: OakSelection<"select", Omit<AccountOper["Projection"], "pay">, Omit<AccountOper["Filter"], "pay">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
accountOper$entity$$aggr?: DeduceAggregation<Omit<AccountOper["Projection"], "pay">, Omit<AccountOper["Filter"], "pay">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
};
|
|
FilterUnit: BasePay.OpFilter & {
|
|
deposit: MakeFilter<Deposit["FilterUnit"]>;
|
|
order: MakeFilter<Order["FilterUnit"]>;
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
creator: MakeFilter<User["FilterUnit"]>;
|
|
account: MakeFilter<Account["FilterUnit"]>;
|
|
apProduct: MakeFilter<ApProduct["FilterUnit"]>;
|
|
offlineAccount: MakeFilter<OfflineAccount["FilterUnit"]>;
|
|
wpProduct: MakeFilter<WpProduct["FilterUnit"]>;
|
|
refund$pay: MakeFilter<Omit<Refund["FilterUnit"], "pay">> & SubQueryPredicateMetadata;
|
|
sysAccountOper$pay: MakeFilter<Omit<SysAccountOper["FilterUnit"], "pay">> & SubQueryPredicateMetadata;
|
|
accountOper$entity: MakeFilter<Omit<AccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Pay["FilterUnit"]>;
|
|
SortAttr: Partial<BasePay.OpSortAttr | {
|
|
deposit: Deposit["SortAttr"];
|
|
order: Order["SortAttr"];
|
|
application: Application["SortAttr"];
|
|
creator: User["SortAttr"];
|
|
account: Account["SortAttr"];
|
|
apProduct: ApProduct["SortAttr"];
|
|
offlineAccount: OfflineAccount["SortAttr"];
|
|
wpProduct: WpProduct["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Pay["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Pay["SortNode"][];
|
|
Selection: OakSelection<"select", Pay["Projection"], Pay["Filter"], Pay["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Pay["Projection"], Pay["Filter"], Pay["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BasePay.OpSchema & {
|
|
deposit?: OakOperation<"create", Deposit["CreateOperationData"]> | OakOperation<BaseDeposit.OpUpdateAction, Deposit["UpdateOperationData"], Deposit["Filter"]>;
|
|
order?: OakOperation<"create", Order["CreateOperationData"]> | OakOperation<BaseOrder.OpUpdateAction, Order["UpdateOperationData"], Order["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]>;
|
|
apProduct?: OakOperation<"create", ApProduct["CreateOperationData"]> | OakOperation<BaseApProduct.OpUpdateAction, ApProduct["UpdateOperationData"], ApProduct["Filter"]>;
|
|
offlineAccount?: OakOperation<"create", OfflineAccount["CreateOperationData"]> | OakOperation<BaseOfflineAccount.OpUpdateAction, OfflineAccount["UpdateOperationData"], OfflineAccount["Filter"]>;
|
|
wpProduct?: OakOperation<"create", WpProduct["CreateOperationData"]> | OakOperation<BaseWpProduct.OpUpdateAction, WpProduct["UpdateOperationData"], WpProduct["Filter"]>;
|
|
refund$pay?: (OakOperation<"create", Omit<Refund["CreateOperationData"], "pay"> | Omit<Refund["CreateOperationData"], "pay">[]> | OakOperation<BaseRefund.OpUpdateAction, Omit<Refund["UpdateOperationData"], "pay">, Refund["Filter"]>)[];
|
|
sysAccountOper$pay?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "pay"> | Omit<SysAccountOper["CreateOperationData"], "pay">[]>[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "pay"> | Omit<AccountOper["CreateOperationData"], "pay">[]>[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Pay["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Pay["CreateOperationData"]>>;
|
|
Create: Pay["CreateSingle"] | Pay["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BasePay.OpSchema & {
|
|
deposit?: OakOperation<"create", Deposit["CreateOperationData"]> | OakOperation<BaseDeposit.OpUpdateAction, Deposit["UpdateOperationData"], Deposit["Filter"]> | OakOperation<"remove", Deposit["RemoveOperationData"], Deposit["Filter"]>;
|
|
order?: OakOperation<"create", Order["CreateOperationData"]> | OakOperation<BaseOrder.OpUpdateAction, Order["UpdateOperationData"], Order["Filter"]> | OakOperation<"remove", Order["RemoveOperationData"], Order["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]> | OakOperation<"remove", Account["RemoveOperationData"], Account["Filter"]>;
|
|
apProduct?: OakOperation<"create", ApProduct["CreateOperationData"]> | OakOperation<BaseApProduct.OpUpdateAction, ApProduct["UpdateOperationData"], ApProduct["Filter"]> | OakOperation<"remove", ApProduct["RemoveOperationData"], ApProduct["Filter"]>;
|
|
offlineAccount?: OakOperation<"create", OfflineAccount["CreateOperationData"]> | OakOperation<BaseOfflineAccount.OpUpdateAction, OfflineAccount["UpdateOperationData"], OfflineAccount["Filter"]> | OakOperation<"remove", OfflineAccount["RemoveOperationData"], OfflineAccount["Filter"]>;
|
|
wpProduct?: OakOperation<"create", WpProduct["CreateOperationData"]> | OakOperation<BaseWpProduct.OpUpdateAction, WpProduct["UpdateOperationData"], WpProduct["Filter"]> | OakOperation<"remove", WpProduct["RemoveOperationData"], WpProduct["Filter"]>;
|
|
refund$pay?: (OakOperation<"create", Omit<Refund["CreateOperationData"], "pay"> | Omit<Refund["CreateOperationData"], "pay">[]> | OakOperation<BaseRefund.OpUpdateAction, Omit<Refund["UpdateOperationData"], "pay">, Refund["Filter"]> | OakOperation<"remove", Refund["RemoveOperationData"], Refund["Filter"]>)[];
|
|
sysAccountOper$pay?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "pay"> | Omit<SysAccountOper["CreateOperationData"], "pay">[]>[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "pay"> | Omit<AccountOper["CreateOperationData"], "pay">[]>[];
|
|
}>;
|
|
Update: OakOperation<BasePay.OpUpdateAction, Pay["UpdateOperationData"], Pay["Filter"], Pay["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"], Pay["Sorter"]>;
|
|
Operation: Pay["Create"] | Pay["Update"] | Pay["Remove"];
|
|
};
|
|
export type Refund = {
|
|
OpSchema: BaseRefund.OpSchema;
|
|
Action: BaseRefund.OpAction;
|
|
Schema: BaseRefund.OpSchema & {
|
|
withdraw?: Withdraw["Schema"];
|
|
pay: Pay["Schema"];
|
|
creator: User["Schema"];
|
|
sysAccountOper$refund?: Array<Omit<SysAccountOper["Schema"], "refund">>;
|
|
accountOper$entity?: Array<Omit<AccountOper["Schema"], "entity">>;
|
|
sysAccountOper$refund$$aggr?: AggregationResult<Omit<SysAccountOper["Schema"], "refund">>;
|
|
accountOper$entity$$aggr?: AggregationResult<Omit<AccountOper["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseRefund.OpProjection & {
|
|
withdraw?: Withdraw["Projection"];
|
|
pay?: Pay["Projection"];
|
|
creator?: User["Projection"];
|
|
sysAccountOper$refund?: OakSelection<"select", Omit<SysAccountOper["Projection"], "refund">, Omit<SysAccountOper["Filter"], "refund">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
sysAccountOper$refund$$aggr?: DeduceAggregation<Omit<SysAccountOper["Projection"], "refund">, Omit<SysAccountOper["Filter"], "refund">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
accountOper$entity?: OakSelection<"select", Omit<AccountOper["Projection"], "refund">, Omit<AccountOper["Filter"], "refund">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
accountOper$entity$$aggr?: DeduceAggregation<Omit<AccountOper["Projection"], "refund">, Omit<AccountOper["Filter"], "refund">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
};
|
|
FilterUnit: BaseRefund.OpFilter & {
|
|
withdraw: MakeFilter<Withdraw["FilterUnit"]>;
|
|
pay: MakeFilter<Pay["FilterUnit"]>;
|
|
creator: MakeFilter<User["FilterUnit"]>;
|
|
sysAccountOper$refund: MakeFilter<Omit<SysAccountOper["FilterUnit"], "refund">> & SubQueryPredicateMetadata;
|
|
accountOper$entity: MakeFilter<Omit<AccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Refund["FilterUnit"]>;
|
|
SortAttr: Partial<BaseRefund.OpSortAttr | {
|
|
withdraw: Withdraw["SortAttr"];
|
|
pay: Pay["SortAttr"];
|
|
creator: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Refund["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Refund["SortNode"][];
|
|
Selection: OakSelection<"select", Refund["Projection"], Refund["Filter"], Refund["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Refund["Projection"], Refund["Filter"], Refund["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseRefund.OpSchema & {
|
|
withdraw?: OakOperation<"create", Withdraw["CreateOperationData"]> | OakOperation<BaseWithdraw.OpUpdateAction, Withdraw["UpdateOperationData"], Withdraw["Filter"]>;
|
|
pay?: OakOperation<"create", Pay["CreateOperationData"]> | OakOperation<BasePay.OpUpdateAction, Pay["UpdateOperationData"], Pay["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
sysAccountOper$refund?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "refund"> | Omit<SysAccountOper["CreateOperationData"], "refund">[]>[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "refund"> | Omit<AccountOper["CreateOperationData"], "refund">[]>[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Refund["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Refund["CreateOperationData"]>>;
|
|
Create: Refund["CreateSingle"] | Refund["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseRefund.OpSchema & {
|
|
withdraw?: OakOperation<"create", Withdraw["CreateOperationData"]> | OakOperation<BaseWithdraw.OpUpdateAction, Withdraw["UpdateOperationData"], Withdraw["Filter"]> | OakOperation<"remove", Withdraw["RemoveOperationData"], Withdraw["Filter"]>;
|
|
pay?: OakOperation<"create", Pay["CreateOperationData"]> | OakOperation<BasePay.OpUpdateAction, Pay["UpdateOperationData"], Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
sysAccountOper$refund?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "refund"> | Omit<SysAccountOper["CreateOperationData"], "refund">[]>[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "refund"> | Omit<AccountOper["CreateOperationData"], "refund">[]>[];
|
|
}>;
|
|
Update: OakOperation<BaseRefund.OpUpdateAction, Refund["UpdateOperationData"], Refund["Filter"], Refund["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Refund["RemoveOperationData"], Refund["Filter"], Refund["Sorter"]>;
|
|
Operation: Refund["Create"] | Refund["Update"] | Refund["Remove"];
|
|
};
|
|
export type Settlement = {
|
|
OpSchema: BaseSettlement.OpSchema;
|
|
Action: BaseSettlement.OpAction;
|
|
Schema: BaseSettlement.OpSchema & {
|
|
account: Account["Schema"];
|
|
plan: SettlePlan["Schema"];
|
|
accountOper$entity?: Array<Omit<AccountOper["Schema"], "entity">>;
|
|
accountOper$entity$$aggr?: AggregationResult<Omit<AccountOper["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseSettlement.OpProjection & {
|
|
account?: Account["Projection"];
|
|
plan?: SettlePlan["Projection"];
|
|
accountOper$entity?: OakSelection<"select", Omit<AccountOper["Projection"], "settlement">, Omit<AccountOper["Filter"], "settlement">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
accountOper$entity$$aggr?: DeduceAggregation<Omit<AccountOper["Projection"], "settlement">, Omit<AccountOper["Filter"], "settlement">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
};
|
|
FilterUnit: BaseSettlement.OpFilter & {
|
|
account: MakeFilter<Account["FilterUnit"]>;
|
|
plan: MakeFilter<SettlePlan["FilterUnit"]>;
|
|
accountOper$entity: MakeFilter<Omit<AccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Settlement["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSettlement.OpSortAttr | {
|
|
account: Account["SortAttr"];
|
|
plan: SettlePlan["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Settlement["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Settlement["SortNode"][];
|
|
Selection: OakSelection<"select", Settlement["Projection"], Settlement["Filter"], Settlement["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Settlement["Projection"], Settlement["Filter"], Settlement["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSettlement.OpSchema & {
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]>;
|
|
plan?: OakOperation<"create", SettlePlan["CreateOperationData"]> | OakOperation<BaseSettlePlan.OpUpdateAction, SettlePlan["UpdateOperationData"], SettlePlan["Filter"]>;
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "settlement"> | Omit<AccountOper["CreateOperationData"], "settlement">[]>[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Settlement["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Settlement["CreateOperationData"]>>;
|
|
Create: Settlement["CreateSingle"] | Settlement["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSettlement.OpSchema & {
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]> | OakOperation<"remove", Account["RemoveOperationData"], Account["Filter"]>;
|
|
plan?: OakOperation<"create", SettlePlan["CreateOperationData"]> | OakOperation<BaseSettlePlan.OpUpdateAction, SettlePlan["UpdateOperationData"], SettlePlan["Filter"]> | OakOperation<"remove", SettlePlan["RemoveOperationData"], SettlePlan["Filter"]>;
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "settlement"> | Omit<AccountOper["CreateOperationData"], "settlement">[]>[];
|
|
}>;
|
|
Update: OakOperation<BaseSettlement.OpUpdateAction, Settlement["UpdateOperationData"], Settlement["Filter"], Settlement["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Settlement["RemoveOperationData"], Settlement["Filter"], Settlement["Sorter"]>;
|
|
Operation: Settlement["Create"] | Settlement["Update"] | Settlement["Remove"];
|
|
};
|
|
export type SettlePlan = {
|
|
OpSchema: BaseSettlePlan.OpSchema;
|
|
Action: BaseSettlePlan.OpAction;
|
|
Schema: BaseSettlePlan.OpSchema & {
|
|
order: Order["Schema"];
|
|
settlement$plan?: Array<Omit<Settlement["Schema"], "plan">>;
|
|
settlement$plan$$aggr?: AggregationResult<Omit<Settlement["Schema"], "plan">>;
|
|
};
|
|
Projection: BaseSettlePlan.OpProjection & {
|
|
order?: Order["Projection"];
|
|
settlement$plan?: OakSelection<"select", Omit<Settlement["Projection"], "settlePlan">, Omit<Settlement["Filter"], "settlePlan">, Settlement["Sorter"]> & {
|
|
$entity: "settlement";
|
|
};
|
|
settlement$plan$$aggr?: DeduceAggregation<Omit<Settlement["Projection"], "settlePlan">, Omit<Settlement["Filter"], "settlePlan">, Settlement["Sorter"]> & {
|
|
$entity: "settlement";
|
|
};
|
|
};
|
|
FilterUnit: BaseSettlePlan.OpFilter & {
|
|
order: MakeFilter<Order["FilterUnit"]>;
|
|
settlement$plan: MakeFilter<Omit<Settlement["FilterUnit"], "plan">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<SettlePlan["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSettlePlan.OpSortAttr | {
|
|
order: Order["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: SettlePlan["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: SettlePlan["SortNode"][];
|
|
Selection: OakSelection<"select", SettlePlan["Projection"], SettlePlan["Filter"], SettlePlan["Sorter"]>;
|
|
Aggregation: DeduceAggregation<SettlePlan["Projection"], SettlePlan["Filter"], SettlePlan["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSettlePlan.OpSchema & {
|
|
order?: OakOperation<"create", Order["CreateOperationData"]> | OakOperation<BaseOrder.OpUpdateAction, Order["UpdateOperationData"], Order["Filter"]>;
|
|
settlement$plan?: (OakOperation<"create", Omit<Settlement["CreateOperationData"], "plan"> | Omit<Settlement["CreateOperationData"], "plan">[]> | OakOperation<BaseSettlement.OpUpdateAction, Omit<Settlement["UpdateOperationData"], "plan">, Settlement["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", SettlePlan["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<SettlePlan["CreateOperationData"]>>;
|
|
Create: SettlePlan["CreateSingle"] | SettlePlan["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSettlePlan.OpSchema & {
|
|
order?: OakOperation<"create", Order["CreateOperationData"]> | OakOperation<BaseOrder.OpUpdateAction, Order["UpdateOperationData"], Order["Filter"]> | OakOperation<"remove", Order["RemoveOperationData"], Order["Filter"]>;
|
|
settlement$plan?: (OakOperation<"create", Omit<Settlement["CreateOperationData"], "plan"> | Omit<Settlement["CreateOperationData"], "plan">[]> | OakOperation<BaseSettlement.OpUpdateAction, Omit<Settlement["UpdateOperationData"], "plan">, Settlement["Filter"]> | OakOperation<"remove", Settlement["RemoveOperationData"], Settlement["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseSettlePlan.OpUpdateAction, SettlePlan["UpdateOperationData"], SettlePlan["Filter"], SettlePlan["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", SettlePlan["RemoveOperationData"], SettlePlan["Filter"], SettlePlan["Sorter"]>;
|
|
Operation: SettlePlan["Create"] | SettlePlan["Update"] | SettlePlan["Remove"];
|
|
};
|
|
export type Ship = {
|
|
OpSchema: BaseShip.OpSchema;
|
|
Action: BaseShip.OpAction;
|
|
Schema: BaseShip.OpSchema & {
|
|
shipService?: ShipService["Schema"];
|
|
to?: Address["Schema"];
|
|
from?: Address["Schema"];
|
|
abstractShipAccount?: AbstractShipAccount["Schema"];
|
|
wechatMpShip?: WechatMpShip["Schema"];
|
|
deposit$ship?: Array<Omit<Deposit["Schema"], "ship">>;
|
|
shipOrder$ship?: Array<Omit<ShipOrder["Schema"], "ship">>;
|
|
deposit$ship$$aggr?: AggregationResult<Omit<Deposit["Schema"], "ship">>;
|
|
shipOrder$ship$$aggr?: AggregationResult<Omit<ShipOrder["Schema"], "ship">>;
|
|
};
|
|
Projection: BaseShip.OpProjection & {
|
|
shipService?: ShipService["Projection"];
|
|
to?: Address["Projection"];
|
|
from?: Address["Projection"];
|
|
abstractShipAccount?: AbstractShipAccount["Projection"];
|
|
wechatMpShip?: WechatMpShip["Projection"];
|
|
deposit$ship?: OakSelection<"select", Omit<Deposit["Projection"], "ship">, Omit<Deposit["Filter"], "ship">, Deposit["Sorter"]> & {
|
|
$entity: "deposit";
|
|
};
|
|
deposit$ship$$aggr?: DeduceAggregation<Omit<Deposit["Projection"], "ship">, Omit<Deposit["Filter"], "ship">, Deposit["Sorter"]> & {
|
|
$entity: "deposit";
|
|
};
|
|
shipOrder$ship?: OakSelection<"select", Omit<ShipOrder["Projection"], "ship">, Omit<ShipOrder["Filter"], "ship">, ShipOrder["Sorter"]> & {
|
|
$entity: "shipOrder";
|
|
};
|
|
shipOrder$ship$$aggr?: DeduceAggregation<Omit<ShipOrder["Projection"], "ship">, Omit<ShipOrder["Filter"], "ship">, ShipOrder["Sorter"]> & {
|
|
$entity: "shipOrder";
|
|
};
|
|
};
|
|
FilterUnit: BaseShip.OpFilter & {
|
|
shipService: MakeFilter<ShipService["FilterUnit"]>;
|
|
to: MakeFilter<Address["FilterUnit"]>;
|
|
from: MakeFilter<Address["FilterUnit"]>;
|
|
abstractShipAccount: MakeFilter<AbstractShipAccount["FilterUnit"]>;
|
|
wechatMpShip: MakeFilter<WechatMpShip["FilterUnit"]>;
|
|
deposit$ship: MakeFilter<Omit<Deposit["FilterUnit"], "ship">> & SubQueryPredicateMetadata;
|
|
shipOrder$ship: MakeFilter<Omit<ShipOrder["FilterUnit"], "ship">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Ship["FilterUnit"]>;
|
|
SortAttr: Partial<BaseShip.OpSortAttr | {
|
|
shipService: ShipService["SortAttr"];
|
|
to: Address["SortAttr"];
|
|
from: Address["SortAttr"];
|
|
abstractShipAccount: AbstractShipAccount["SortAttr"];
|
|
wechatMpShip: WechatMpShip["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Ship["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Ship["SortNode"][];
|
|
Selection: OakSelection<"select", Ship["Projection"], Ship["Filter"], Ship["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Ship["Projection"], Ship["Filter"], Ship["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseShip.OpSchema & {
|
|
shipService?: OakOperation<"create", ShipService["CreateOperationData"]> | OakOperation<BaseShipService.OpUpdateAction, ShipService["UpdateOperationData"], ShipService["Filter"]>;
|
|
to?: OakOperation<"create", Address["CreateOperationData"]> | OakOperation<BaseAddress.OpUpdateAction, Address["UpdateOperationData"], Address["Filter"]>;
|
|
from?: OakOperation<"create", Address["CreateOperationData"]> | OakOperation<BaseAddress.OpUpdateAction, Address["UpdateOperationData"], Address["Filter"]>;
|
|
abstractShipAccount?: OakOperation<"create", AbstractShipAccount["CreateOperationData"]> | OakOperation<BaseAbstractShipAccount.OpUpdateAction, AbstractShipAccount["UpdateOperationData"], AbstractShipAccount["Filter"]>;
|
|
wechatMpShip?: OakOperation<"create", WechatMpShip["CreateOperationData"]> | OakOperation<BaseWechatMpShip.OpUpdateAction, WechatMpShip["UpdateOperationData"], WechatMpShip["Filter"]>;
|
|
deposit$ship?: (OakOperation<"create", Omit<Deposit["CreateOperationData"], "ship"> | Omit<Deposit["CreateOperationData"], "ship">[]> | OakOperation<BaseDeposit.OpUpdateAction, Omit<Deposit["UpdateOperationData"], "ship">, Deposit["Filter"]>)[];
|
|
shipOrder$ship?: (OakOperation<"create", Omit<ShipOrder["CreateOperationData"], "ship"> | Omit<ShipOrder["CreateOperationData"], "ship">[]> | OakOperation<BaseShipOrder.OpUpdateAction, Omit<ShipOrder["UpdateOperationData"], "ship">, ShipOrder["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Ship["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Ship["CreateOperationData"]>>;
|
|
Create: Ship["CreateSingle"] | Ship["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseShip.OpSchema & {
|
|
shipService?: OakOperation<"create", ShipService["CreateOperationData"]> | OakOperation<BaseShipService.OpUpdateAction, ShipService["UpdateOperationData"], ShipService["Filter"]> | OakOperation<"remove", ShipService["RemoveOperationData"], ShipService["Filter"]>;
|
|
to?: OakOperation<"create", Address["CreateOperationData"]> | OakOperation<BaseAddress.OpUpdateAction, Address["UpdateOperationData"], Address["Filter"]> | OakOperation<"remove", Address["RemoveOperationData"], Address["Filter"]>;
|
|
from?: OakOperation<"create", Address["CreateOperationData"]> | OakOperation<BaseAddress.OpUpdateAction, Address["UpdateOperationData"], Address["Filter"]> | OakOperation<"remove", Address["RemoveOperationData"], Address["Filter"]>;
|
|
abstractShipAccount?: OakOperation<"create", AbstractShipAccount["CreateOperationData"]> | OakOperation<BaseAbstractShipAccount.OpUpdateAction, AbstractShipAccount["UpdateOperationData"], AbstractShipAccount["Filter"]> | OakOperation<"remove", AbstractShipAccount["RemoveOperationData"], AbstractShipAccount["Filter"]>;
|
|
wechatMpShip?: OakOperation<"create", WechatMpShip["CreateOperationData"]> | OakOperation<BaseWechatMpShip.OpUpdateAction, WechatMpShip["UpdateOperationData"], WechatMpShip["Filter"]> | OakOperation<"remove", WechatMpShip["RemoveOperationData"], WechatMpShip["Filter"]>;
|
|
deposit$ship?: (OakOperation<"create", Omit<Deposit["CreateOperationData"], "ship"> | Omit<Deposit["CreateOperationData"], "ship">[]> | OakOperation<BaseDeposit.OpUpdateAction, Omit<Deposit["UpdateOperationData"], "ship">, Deposit["Filter"]> | OakOperation<"remove", Deposit["RemoveOperationData"], Deposit["Filter"]>)[];
|
|
shipOrder$ship?: (OakOperation<"create", Omit<ShipOrder["CreateOperationData"], "ship"> | Omit<ShipOrder["CreateOperationData"], "ship">[]> | OakOperation<BaseShipOrder.OpUpdateAction, Omit<ShipOrder["UpdateOperationData"], "ship">, ShipOrder["Filter"]> | OakOperation<"remove", ShipOrder["RemoveOperationData"], ShipOrder["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseShip.OpUpdateAction, Ship["UpdateOperationData"], Ship["Filter"], Ship["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Ship["RemoveOperationData"], Ship["Filter"], Ship["Sorter"]>;
|
|
Operation: Ship["Create"] | Ship["Update"] | Ship["Remove"];
|
|
};
|
|
export type ShipCompany = {
|
|
OpSchema: BaseShipCompany.OpSchema;
|
|
Action: BaseShipCompany.OpAction;
|
|
Schema: BaseShipCompany.OpSchema & {
|
|
shipService$shipCompany?: Array<Omit<ShipService["Schema"], "shipCompany">>;
|
|
shipService$shipCompany$$aggr?: AggregationResult<Omit<ShipService["Schema"], "shipCompany">>;
|
|
};
|
|
Projection: BaseShipCompany.OpProjection & {
|
|
shipService$shipCompany?: OakSelection<"select", Omit<ShipService["Projection"], "shipCompany">, Omit<ShipService["Filter"], "shipCompany">, ShipService["Sorter"]> & {
|
|
$entity: "shipService";
|
|
};
|
|
shipService$shipCompany$$aggr?: DeduceAggregation<Omit<ShipService["Projection"], "shipCompany">, Omit<ShipService["Filter"], "shipCompany">, ShipService["Sorter"]> & {
|
|
$entity: "shipService";
|
|
};
|
|
};
|
|
FilterUnit: BaseShipCompany.OpFilter & {
|
|
shipService$shipCompany: MakeFilter<Omit<ShipService["FilterUnit"], "shipCompany">> & SubQueryPredicateMetadata;
|
|
} & FulltextFilter;
|
|
Filter: MakeFilter<ShipCompany["FilterUnit"]>;
|
|
SortAttr: Partial<BaseShipCompany.OpSortAttr | {}>;
|
|
SortNode: {
|
|
$attr: ShipCompany["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ShipCompany["SortNode"][];
|
|
Selection: OakSelection<"select", ShipCompany["Projection"], ShipCompany["Filter"], ShipCompany["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ShipCompany["Projection"], ShipCompany["Filter"], ShipCompany["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseShipCompany.OpSchema & {
|
|
shipService$shipCompany?: (OakOperation<"create", Omit<ShipService["CreateOperationData"], "shipCompany"> | Omit<ShipService["CreateOperationData"], "shipCompany">[]> | OakOperation<BaseShipService.OpUpdateAction, Omit<ShipService["UpdateOperationData"], "shipCompany">, ShipService["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ShipCompany["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ShipCompany["CreateOperationData"]>>;
|
|
Create: ShipCompany["CreateSingle"] | ShipCompany["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseShipCompany.OpSchema & {
|
|
shipService$shipCompany?: (OakOperation<"create", Omit<ShipService["CreateOperationData"], "shipCompany"> | Omit<ShipService["CreateOperationData"], "shipCompany">[]> | OakOperation<BaseShipService.OpUpdateAction, Omit<ShipService["UpdateOperationData"], "shipCompany">, ShipService["Filter"]> | OakOperation<"remove", ShipService["RemoveOperationData"], ShipService["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseShipCompany.OpUpdateAction, ShipCompany["UpdateOperationData"], ShipCompany["Filter"], ShipCompany["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ShipCompany["RemoveOperationData"], ShipCompany["Filter"], ShipCompany["Sorter"]>;
|
|
Operation: ShipCompany["Create"] | ShipCompany["Update"] | ShipCompany["Remove"];
|
|
};
|
|
export type ShipOrder = {
|
|
OpSchema: BaseShipOrder.OpSchema;
|
|
Action: BaseShipOrder.OpAction;
|
|
Schema: BaseShipOrder.OpSchema & {
|
|
ship: Ship["Schema"];
|
|
order: Order["Schema"];
|
|
};
|
|
Projection: BaseShipOrder.OpProjection & {
|
|
ship?: Ship["Projection"];
|
|
order?: Order["Projection"];
|
|
};
|
|
FilterUnit: BaseShipOrder.OpFilter & {
|
|
ship: MakeFilter<Ship["FilterUnit"]>;
|
|
order: MakeFilter<Order["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<ShipOrder["FilterUnit"]>;
|
|
SortAttr: Partial<BaseShipOrder.OpSortAttr | {
|
|
ship: Ship["SortAttr"];
|
|
order: Order["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ShipOrder["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ShipOrder["SortNode"][];
|
|
Selection: OakSelection<"select", ShipOrder["Projection"], ShipOrder["Filter"], ShipOrder["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ShipOrder["Projection"], ShipOrder["Filter"], ShipOrder["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseShipOrder.OpSchema & {
|
|
ship?: OakOperation<"create", Ship["CreateOperationData"]> | OakOperation<BaseShip.OpUpdateAction, Ship["UpdateOperationData"], Ship["Filter"]>;
|
|
order?: OakOperation<"create", Order["CreateOperationData"]> | OakOperation<BaseOrder.OpUpdateAction, Order["UpdateOperationData"], Order["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ShipOrder["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ShipOrder["CreateOperationData"]>>;
|
|
Create: ShipOrder["CreateSingle"] | ShipOrder["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseShipOrder.OpSchema & {
|
|
ship?: OakOperation<"create", Ship["CreateOperationData"]> | OakOperation<BaseShip.OpUpdateAction, Ship["UpdateOperationData"], Ship["Filter"]> | OakOperation<"remove", Ship["RemoveOperationData"], Ship["Filter"]>;
|
|
order?: OakOperation<"create", Order["CreateOperationData"]> | OakOperation<BaseOrder.OpUpdateAction, Order["UpdateOperationData"], Order["Filter"]> | OakOperation<"remove", Order["RemoveOperationData"], Order["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseShipOrder.OpUpdateAction, ShipOrder["UpdateOperationData"], ShipOrder["Filter"], ShipOrder["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ShipOrder["RemoveOperationData"], ShipOrder["Filter"], ShipOrder["Sorter"]>;
|
|
Operation: ShipOrder["Create"] | ShipOrder["Update"] | ShipOrder["Remove"];
|
|
};
|
|
export type ShipService = {
|
|
OpSchema: BaseShipService.OpSchema;
|
|
Action: BaseShipService.OpAction;
|
|
Schema: BaseShipService.OpSchema & {
|
|
shipCompany: ShipCompany["Schema"];
|
|
ship$shipService?: Array<Omit<Ship["Schema"], "shipService">>;
|
|
shipServiceSystem$shipService?: Array<Omit<ShipServiceSystem["Schema"], "shipService">>;
|
|
ship$shipService$$aggr?: AggregationResult<Omit<Ship["Schema"], "shipService">>;
|
|
shipServiceSystem$shipService$$aggr?: AggregationResult<Omit<ShipServiceSystem["Schema"], "shipService">>;
|
|
};
|
|
Projection: BaseShipService.OpProjection & {
|
|
shipCompany?: ShipCompany["Projection"];
|
|
ship$shipService?: OakSelection<"select", Omit<Ship["Projection"], "shipService">, Omit<Ship["Filter"], "shipService">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
ship$shipService$$aggr?: DeduceAggregation<Omit<Ship["Projection"], "shipService">, Omit<Ship["Filter"], "shipService">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
shipServiceSystem$shipService?: OakSelection<"select", Omit<ShipServiceSystem["Projection"], "shipService">, Omit<ShipServiceSystem["Filter"], "shipService">, ShipServiceSystem["Sorter"]> & {
|
|
$entity: "shipServiceSystem";
|
|
};
|
|
shipServiceSystem$shipService$$aggr?: DeduceAggregation<Omit<ShipServiceSystem["Projection"], "shipService">, Omit<ShipServiceSystem["Filter"], "shipService">, ShipServiceSystem["Sorter"]> & {
|
|
$entity: "shipServiceSystem";
|
|
};
|
|
};
|
|
FilterUnit: BaseShipService.OpFilter & {
|
|
shipCompany: MakeFilter<ShipCompany["FilterUnit"]>;
|
|
ship$shipService: MakeFilter<Omit<Ship["FilterUnit"], "shipService">> & SubQueryPredicateMetadata;
|
|
shipServiceSystem$shipService: MakeFilter<Omit<ShipServiceSystem["FilterUnit"], "shipService">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<ShipService["FilterUnit"]>;
|
|
SortAttr: Partial<BaseShipService.OpSortAttr | {
|
|
shipCompany: ShipCompany["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ShipService["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ShipService["SortNode"][];
|
|
Selection: OakSelection<"select", ShipService["Projection"], ShipService["Filter"], ShipService["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ShipService["Projection"], ShipService["Filter"], ShipService["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseShipService.OpSchema & {
|
|
shipCompany?: OakOperation<"create", ShipCompany["CreateOperationData"]> | OakOperation<BaseShipCompany.OpUpdateAction, ShipCompany["UpdateOperationData"], ShipCompany["Filter"]>;
|
|
ship$shipService?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "shipService"> | Omit<Ship["CreateOperationData"], "shipService">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "shipService">, Ship["Filter"]>)[];
|
|
shipServiceSystem$shipService?: (OakOperation<"create", Omit<ShipServiceSystem["CreateOperationData"], "shipService"> | Omit<ShipServiceSystem["CreateOperationData"], "shipService">[]> | OakOperation<BaseShipServiceSystem.OpUpdateAction, Omit<ShipServiceSystem["UpdateOperationData"], "shipService">, ShipServiceSystem["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ShipService["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ShipService["CreateOperationData"]>>;
|
|
Create: ShipService["CreateSingle"] | ShipService["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseShipService.OpSchema & {
|
|
shipCompany?: OakOperation<"create", ShipCompany["CreateOperationData"]> | OakOperation<BaseShipCompany.OpUpdateAction, ShipCompany["UpdateOperationData"], ShipCompany["Filter"]> | OakOperation<"remove", ShipCompany["RemoveOperationData"], ShipCompany["Filter"]>;
|
|
ship$shipService?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "shipService"> | Omit<Ship["CreateOperationData"], "shipService">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "shipService">, Ship["Filter"]> | OakOperation<"remove", Ship["RemoveOperationData"], Ship["Filter"]>)[];
|
|
shipServiceSystem$shipService?: (OakOperation<"create", Omit<ShipServiceSystem["CreateOperationData"], "shipService"> | Omit<ShipServiceSystem["CreateOperationData"], "shipService">[]> | OakOperation<BaseShipServiceSystem.OpUpdateAction, Omit<ShipServiceSystem["UpdateOperationData"], "shipService">, ShipServiceSystem["Filter"]> | OakOperation<"remove", ShipServiceSystem["RemoveOperationData"], ShipServiceSystem["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseShipService.OpUpdateAction, ShipService["UpdateOperationData"], ShipService["Filter"], ShipService["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ShipService["RemoveOperationData"], ShipService["Filter"], ShipService["Sorter"]>;
|
|
Operation: ShipService["Create"] | ShipService["Update"] | ShipService["Remove"];
|
|
};
|
|
export type ShipServiceSystem = {
|
|
OpSchema: BaseShipServiceSystem.OpSchema;
|
|
Action: BaseShipServiceSystem.OpAction;
|
|
Schema: BaseShipServiceSystem.OpSchema & {
|
|
shipService: ShipService["Schema"];
|
|
system: System["Schema"];
|
|
};
|
|
Projection: BaseShipServiceSystem.OpProjection & {
|
|
shipService?: ShipService["Projection"];
|
|
system?: System["Projection"];
|
|
};
|
|
FilterUnit: BaseShipServiceSystem.OpFilter & {
|
|
shipService: MakeFilter<ShipService["FilterUnit"]>;
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<ShipServiceSystem["FilterUnit"]>;
|
|
SortAttr: Partial<BaseShipServiceSystem.OpSortAttr | {
|
|
shipService: ShipService["SortAttr"];
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: ShipServiceSystem["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: ShipServiceSystem["SortNode"][];
|
|
Selection: OakSelection<"select", ShipServiceSystem["Projection"], ShipServiceSystem["Filter"], ShipServiceSystem["Sorter"]>;
|
|
Aggregation: DeduceAggregation<ShipServiceSystem["Projection"], ShipServiceSystem["Filter"], ShipServiceSystem["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseShipServiceSystem.OpSchema & {
|
|
shipService?: OakOperation<"create", ShipService["CreateOperationData"]> | OakOperation<BaseShipService.OpUpdateAction, ShipService["UpdateOperationData"], ShipService["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", ShipServiceSystem["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<ShipServiceSystem["CreateOperationData"]>>;
|
|
Create: ShipServiceSystem["CreateSingle"] | ShipServiceSystem["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseShipServiceSystem.OpSchema & {
|
|
shipService?: OakOperation<"create", ShipService["CreateOperationData"]> | OakOperation<BaseShipService.OpUpdateAction, ShipService["UpdateOperationData"], ShipService["Filter"]> | OakOperation<"remove", ShipService["RemoveOperationData"], ShipService["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseShipServiceSystem.OpUpdateAction, ShipServiceSystem["UpdateOperationData"], ShipServiceSystem["Filter"], ShipServiceSystem["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", ShipServiceSystem["RemoveOperationData"], ShipServiceSystem["Filter"], ShipServiceSystem["Sorter"]>;
|
|
Operation: ShipServiceSystem["Create"] | ShipServiceSystem["Update"] | ShipServiceSystem["Remove"];
|
|
};
|
|
export type SysAccountMove = {
|
|
OpSchema: BaseSysAccountMove.OpSchema;
|
|
Action: BaseSysAccountMove.OpAction;
|
|
Schema: BaseSysAccountMove.OpSchema & {
|
|
operator: User["Schema"];
|
|
system: System["Schema"];
|
|
sysAccountOper$sysAccountMove?: Array<Omit<SysAccountOper["Schema"], "sysAccountMove">>;
|
|
sysAccountOper$sysAccountMove$$aggr?: AggregationResult<Omit<SysAccountOper["Schema"], "sysAccountMove">>;
|
|
};
|
|
Projection: BaseSysAccountMove.OpProjection & {
|
|
operator?: User["Projection"];
|
|
system?: System["Projection"];
|
|
sysAccountOper$sysAccountMove?: OakSelection<"select", Omit<SysAccountOper["Projection"], "sysAccountMove">, Omit<SysAccountOper["Filter"], "sysAccountMove">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
sysAccountOper$sysAccountMove$$aggr?: DeduceAggregation<Omit<SysAccountOper["Projection"], "sysAccountMove">, Omit<SysAccountOper["Filter"], "sysAccountMove">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
};
|
|
FilterUnit: BaseSysAccountMove.OpFilter & {
|
|
operator: MakeFilter<User["FilterUnit"]>;
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
sysAccountOper$sysAccountMove: MakeFilter<Omit<SysAccountOper["FilterUnit"], "sysAccountMove">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<SysAccountMove["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSysAccountMove.OpSortAttr | {
|
|
operator: User["SortAttr"];
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: SysAccountMove["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: SysAccountMove["SortNode"][];
|
|
Selection: OakSelection<"select", SysAccountMove["Projection"], SysAccountMove["Filter"], SysAccountMove["Sorter"]>;
|
|
Aggregation: DeduceAggregation<SysAccountMove["Projection"], SysAccountMove["Filter"], SysAccountMove["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSysAccountMove.OpSchema & {
|
|
operator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
sysAccountOper$sysAccountMove?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "sysAccountMove"> | Omit<SysAccountOper["CreateOperationData"], "sysAccountMove">[]>[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", SysAccountMove["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<SysAccountMove["CreateOperationData"]>>;
|
|
Create: SysAccountMove["CreateSingle"] | SysAccountMove["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSysAccountMove.OpSchema & {
|
|
operator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
sysAccountOper$sysAccountMove?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "sysAccountMove"> | Omit<SysAccountOper["CreateOperationData"], "sysAccountMove">[]>[];
|
|
}>;
|
|
Update: OakOperation<BaseSysAccountMove.OpUpdateAction, SysAccountMove["UpdateOperationData"], SysAccountMove["Filter"], SysAccountMove["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", SysAccountMove["RemoveOperationData"], SysAccountMove["Filter"], SysAccountMove["Sorter"]>;
|
|
Operation: SysAccountMove["Create"] | SysAccountMove["Update"] | SysAccountMove["Remove"];
|
|
};
|
|
export type SysAccountOper = {
|
|
OpSchema: BaseSysAccountOper.OpSchema;
|
|
Action: BaseSysAccountOper.OpAction;
|
|
Schema: BaseSysAccountOper.OpSchema & {
|
|
pay?: Pay["Schema"];
|
|
refund?: Refund["Schema"];
|
|
withdrawTransfer?: WithdrawTransfer["Schema"];
|
|
sysAccountMove?: SysAccountMove["Schema"];
|
|
apAccount?: ApAccount["Schema"];
|
|
offlineAccount?: OfflineAccount["Schema"];
|
|
wpAccount?: WpAccount["Schema"];
|
|
};
|
|
Projection: BaseSysAccountOper.OpProjection & {
|
|
pay?: Pay["Projection"];
|
|
refund?: Refund["Projection"];
|
|
withdrawTransfer?: WithdrawTransfer["Projection"];
|
|
sysAccountMove?: SysAccountMove["Projection"];
|
|
apAccount?: ApAccount["Projection"];
|
|
offlineAccount?: OfflineAccount["Projection"];
|
|
wpAccount?: WpAccount["Projection"];
|
|
};
|
|
FilterUnit: BaseSysAccountOper.OpFilter & {
|
|
pay: MakeFilter<Pay["FilterUnit"]>;
|
|
refund: MakeFilter<Refund["FilterUnit"]>;
|
|
withdrawTransfer: MakeFilter<WithdrawTransfer["FilterUnit"]>;
|
|
sysAccountMove: MakeFilter<SysAccountMove["FilterUnit"]>;
|
|
apAccount: MakeFilter<ApAccount["FilterUnit"]>;
|
|
offlineAccount: MakeFilter<OfflineAccount["FilterUnit"]>;
|
|
wpAccount: MakeFilter<WpAccount["FilterUnit"]>;
|
|
};
|
|
Filter: MakeFilter<SysAccountOper["FilterUnit"]>;
|
|
SortAttr: Partial<BaseSysAccountOper.OpSortAttr | {
|
|
pay: Pay["SortAttr"];
|
|
refund: Refund["SortAttr"];
|
|
withdrawTransfer: WithdrawTransfer["SortAttr"];
|
|
sysAccountMove: SysAccountMove["SortAttr"];
|
|
apAccount: ApAccount["SortAttr"];
|
|
offlineAccount: OfflineAccount["SortAttr"];
|
|
wpAccount: WpAccount["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: SysAccountOper["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: SysAccountOper["SortNode"][];
|
|
Selection: OakSelection<"select", SysAccountOper["Projection"], SysAccountOper["Filter"], SysAccountOper["Sorter"]>;
|
|
Aggregation: DeduceAggregation<SysAccountOper["Projection"], SysAccountOper["Filter"], SysAccountOper["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseSysAccountOper.OpSchema & {
|
|
pay?: OakOperation<"create", Pay["CreateOperationData"]> | OakOperation<BasePay.OpUpdateAction, Pay["UpdateOperationData"], Pay["Filter"]>;
|
|
refund?: OakOperation<"create", Refund["CreateOperationData"]> | OakOperation<BaseRefund.OpUpdateAction, Refund["UpdateOperationData"], Refund["Filter"]>;
|
|
withdrawTransfer?: OakOperation<"create", WithdrawTransfer["CreateOperationData"]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, WithdrawTransfer["UpdateOperationData"], WithdrawTransfer["Filter"]>;
|
|
sysAccountMove?: OakOperation<"create", SysAccountMove["CreateOperationData"]>;
|
|
apAccount?: OakOperation<"create", ApAccount["CreateOperationData"]> | OakOperation<BaseApAccount.OpUpdateAction, ApAccount["UpdateOperationData"], ApAccount["Filter"]>;
|
|
offlineAccount?: OakOperation<"create", OfflineAccount["CreateOperationData"]> | OakOperation<BaseOfflineAccount.OpUpdateAction, OfflineAccount["UpdateOperationData"], OfflineAccount["Filter"]>;
|
|
wpAccount?: OakOperation<"create", WpAccount["CreateOperationData"]> | OakOperation<BaseWpAccount.OpUpdateAction, WpAccount["UpdateOperationData"], WpAccount["Filter"]>;
|
|
}>;
|
|
CreateSingle: OakOperation<"create", SysAccountOper["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<SysAccountOper["CreateOperationData"]>>;
|
|
Create: SysAccountOper["CreateSingle"] | SysAccountOper["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseSysAccountOper.OpSchema & {
|
|
pay?: OakOperation<"create", Pay["CreateOperationData"]> | OakOperation<BasePay.OpUpdateAction, Pay["UpdateOperationData"], Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>;
|
|
refund?: OakOperation<"create", Refund["CreateOperationData"]> | OakOperation<BaseRefund.OpUpdateAction, Refund["UpdateOperationData"], Refund["Filter"]> | OakOperation<"remove", Refund["RemoveOperationData"], Refund["Filter"]>;
|
|
withdrawTransfer?: OakOperation<"create", WithdrawTransfer["CreateOperationData"]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, WithdrawTransfer["UpdateOperationData"], WithdrawTransfer["Filter"]> | OakOperation<"remove", WithdrawTransfer["RemoveOperationData"], WithdrawTransfer["Filter"]>;
|
|
sysAccountMove?: OakOperation<"create", SysAccountMove["CreateOperationData"]>;
|
|
apAccount?: OakOperation<"create", ApAccount["CreateOperationData"]> | OakOperation<BaseApAccount.OpUpdateAction, ApAccount["UpdateOperationData"], ApAccount["Filter"]> | OakOperation<"remove", ApAccount["RemoveOperationData"], ApAccount["Filter"]>;
|
|
offlineAccount?: OakOperation<"create", OfflineAccount["CreateOperationData"]> | OakOperation<BaseOfflineAccount.OpUpdateAction, OfflineAccount["UpdateOperationData"], OfflineAccount["Filter"]> | OakOperation<"remove", OfflineAccount["RemoveOperationData"], OfflineAccount["Filter"]>;
|
|
wpAccount?: OakOperation<"create", WpAccount["CreateOperationData"]> | OakOperation<BaseWpAccount.OpUpdateAction, WpAccount["UpdateOperationData"], WpAccount["Filter"]> | OakOperation<"remove", WpAccount["RemoveOperationData"], WpAccount["Filter"]>;
|
|
}>;
|
|
Update: OakOperation<BaseSysAccountOper.OpUpdateAction, SysAccountOper["UpdateOperationData"], SysAccountOper["Filter"], SysAccountOper["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", SysAccountOper["RemoveOperationData"], SysAccountOper["Filter"], SysAccountOper["Sorter"]>;
|
|
Operation: SysAccountOper["Create"] | SysAccountOper["Update"] | SysAccountOper["Remove"];
|
|
};
|
|
export type WechatMpShip = {
|
|
OpSchema: BaseWechatMpShip.OpSchema;
|
|
Action: BaseWechatMpShip.OpAction;
|
|
Schema: BaseWechatMpShip.OpSchema & {
|
|
system: System["Schema"];
|
|
application: Application["Schema"];
|
|
ship$entity?: Array<Omit<Ship["Schema"], "entity">>;
|
|
ship$entity$$aggr?: AggregationResult<Omit<Ship["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseWechatMpShip.OpProjection & {
|
|
system?: System["Projection"];
|
|
application?: Application["Projection"];
|
|
ship$entity?: OakSelection<"select", Omit<Ship["Projection"], "wechatMpShip">, Omit<Ship["Filter"], "wechatMpShip">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
ship$entity$$aggr?: DeduceAggregation<Omit<Ship["Projection"], "wechatMpShip">, Omit<Ship["Filter"], "wechatMpShip">, Ship["Sorter"]> & {
|
|
$entity: "ship";
|
|
};
|
|
};
|
|
FilterUnit: BaseWechatMpShip.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
ship$entity: MakeFilter<Omit<Ship["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WechatMpShip["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatMpShip.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
application: Application["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatMpShip["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatMpShip["SortNode"][];
|
|
Selection: OakSelection<"select", WechatMpShip["Projection"], WechatMpShip["Filter"], WechatMpShip["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatMpShip["Projection"], WechatMpShip["Filter"], WechatMpShip["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatMpShip.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
ship$entity?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "wechatMpShip"> | Omit<Ship["CreateOperationData"], "wechatMpShip">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "wechatMpShip">, Ship["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatMpShip["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatMpShip["CreateOperationData"]>>;
|
|
Create: WechatMpShip["CreateSingle"] | WechatMpShip["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatMpShip.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
ship$entity?: (OakOperation<"create", Omit<Ship["CreateOperationData"], "wechatMpShip"> | Omit<Ship["CreateOperationData"], "wechatMpShip">[]> | OakOperation<BaseShip.OpUpdateAction, Omit<Ship["UpdateOperationData"], "wechatMpShip">, Ship["Filter"]> | OakOperation<"remove", Ship["RemoveOperationData"], Ship["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWechatMpShip.OpUpdateAction, WechatMpShip["UpdateOperationData"], WechatMpShip["Filter"], WechatMpShip["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatMpShip["RemoveOperationData"], WechatMpShip["Filter"], WechatMpShip["Sorter"]>;
|
|
Operation: WechatMpShip["Create"] | WechatMpShip["Update"] | WechatMpShip["Remove"];
|
|
};
|
|
export type WechatPay = {
|
|
OpSchema: BaseWechatPay.OpSchema;
|
|
Action: BaseWechatPay.OpAction;
|
|
Schema: BaseWechatPay.OpSchema & {
|
|
system: System["Schema"];
|
|
wpAccount$wechatPay?: Array<Omit<WpAccount["Schema"], "wechatPay">>;
|
|
wpAccount$wechatPay$$aggr?: AggregationResult<Omit<WpAccount["Schema"], "wechatPay">>;
|
|
};
|
|
Projection: BaseWechatPay.OpProjection & {
|
|
system?: System["Projection"];
|
|
wpAccount$wechatPay?: OakSelection<"select", Omit<WpAccount["Projection"], "wechatPay">, Omit<WpAccount["Filter"], "wechatPay">, WpAccount["Sorter"]> & {
|
|
$entity: "wpAccount";
|
|
};
|
|
wpAccount$wechatPay$$aggr?: DeduceAggregation<Omit<WpAccount["Projection"], "wechatPay">, Omit<WpAccount["Filter"], "wechatPay">, WpAccount["Sorter"]> & {
|
|
$entity: "wpAccount";
|
|
};
|
|
};
|
|
FilterUnit: BaseWechatPay.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
wpAccount$wechatPay: MakeFilter<Omit<WpAccount["FilterUnit"], "wechatPay">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WechatPay["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWechatPay.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WechatPay["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WechatPay["SortNode"][];
|
|
Selection: OakSelection<"select", WechatPay["Projection"], WechatPay["Filter"], WechatPay["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WechatPay["Projection"], WechatPay["Filter"], WechatPay["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWechatPay.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
wpAccount$wechatPay?: (OakOperation<"create", Omit<WpAccount["CreateOperationData"], "wechatPay"> | Omit<WpAccount["CreateOperationData"], "wechatPay">[]> | OakOperation<BaseWpAccount.OpUpdateAction, Omit<WpAccount["UpdateOperationData"], "wechatPay">, WpAccount["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WechatPay["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WechatPay["CreateOperationData"]>>;
|
|
Create: WechatPay["CreateSingle"] | WechatPay["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWechatPay.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
wpAccount$wechatPay?: (OakOperation<"create", Omit<WpAccount["CreateOperationData"], "wechatPay"> | Omit<WpAccount["CreateOperationData"], "wechatPay">[]> | OakOperation<BaseWpAccount.OpUpdateAction, Omit<WpAccount["UpdateOperationData"], "wechatPay">, WpAccount["Filter"]> | OakOperation<"remove", WpAccount["RemoveOperationData"], WpAccount["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWechatPay.OpUpdateAction, WechatPay["UpdateOperationData"], WechatPay["Filter"], WechatPay["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WechatPay["RemoveOperationData"], WechatPay["Filter"], WechatPay["Sorter"]>;
|
|
Operation: WechatPay["Create"] | WechatPay["Update"] | WechatPay["Remove"];
|
|
};
|
|
export type Withdraw = {
|
|
OpSchema: BaseWithdraw.OpSchema;
|
|
Action: BaseWithdraw.OpAction;
|
|
Schema: BaseWithdraw.OpSchema & {
|
|
account: Account["Schema"];
|
|
creator: User["Schema"];
|
|
refund$withdraw?: Array<Omit<Refund["Schema"], "withdraw">>;
|
|
withdrawTransfer$withdraw?: Array<Omit<WithdrawTransfer["Schema"], "withdraw">>;
|
|
accountOper$entity?: Array<Omit<AccountOper["Schema"], "entity">>;
|
|
refund$withdraw$$aggr?: AggregationResult<Omit<Refund["Schema"], "withdraw">>;
|
|
withdrawTransfer$withdraw$$aggr?: AggregationResult<Omit<WithdrawTransfer["Schema"], "withdraw">>;
|
|
accountOper$entity$$aggr?: AggregationResult<Omit<AccountOper["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseWithdraw.OpProjection & {
|
|
account?: Account["Projection"];
|
|
creator?: User["Projection"];
|
|
refund$withdraw?: OakSelection<"select", Omit<Refund["Projection"], "withdraw">, Omit<Refund["Filter"], "withdraw">, Refund["Sorter"]> & {
|
|
$entity: "refund";
|
|
};
|
|
refund$withdraw$$aggr?: DeduceAggregation<Omit<Refund["Projection"], "withdraw">, Omit<Refund["Filter"], "withdraw">, Refund["Sorter"]> & {
|
|
$entity: "refund";
|
|
};
|
|
withdrawTransfer$withdraw?: OakSelection<"select", Omit<WithdrawTransfer["Projection"], "withdraw">, Omit<WithdrawTransfer["Filter"], "withdraw">, WithdrawTransfer["Sorter"]> & {
|
|
$entity: "withdrawTransfer";
|
|
};
|
|
withdrawTransfer$withdraw$$aggr?: DeduceAggregation<Omit<WithdrawTransfer["Projection"], "withdraw">, Omit<WithdrawTransfer["Filter"], "withdraw">, WithdrawTransfer["Sorter"]> & {
|
|
$entity: "withdrawTransfer";
|
|
};
|
|
accountOper$entity?: OakSelection<"select", Omit<AccountOper["Projection"], "withdraw">, Omit<AccountOper["Filter"], "withdraw">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
accountOper$entity$$aggr?: DeduceAggregation<Omit<AccountOper["Projection"], "withdraw">, Omit<AccountOper["Filter"], "withdraw">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
};
|
|
FilterUnit: BaseWithdraw.OpFilter & {
|
|
account: MakeFilter<Account["FilterUnit"]>;
|
|
creator: MakeFilter<User["FilterUnit"]>;
|
|
refund$withdraw: MakeFilter<Omit<Refund["FilterUnit"], "withdraw">> & SubQueryPredicateMetadata;
|
|
withdrawTransfer$withdraw: MakeFilter<Omit<WithdrawTransfer["FilterUnit"], "withdraw">> & SubQueryPredicateMetadata;
|
|
accountOper$entity: MakeFilter<Omit<AccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<Withdraw["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWithdraw.OpSortAttr | {
|
|
account: Account["SortAttr"];
|
|
creator: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: Withdraw["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: Withdraw["SortNode"][];
|
|
Selection: OakSelection<"select", Withdraw["Projection"], Withdraw["Filter"], Withdraw["Sorter"]>;
|
|
Aggregation: DeduceAggregation<Withdraw["Projection"], Withdraw["Filter"], Withdraw["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWithdraw.OpSchema & {
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
refund$withdraw?: (OakOperation<"create", Omit<Refund["CreateOperationData"], "withdraw"> | Omit<Refund["CreateOperationData"], "withdraw">[]> | OakOperation<BaseRefund.OpUpdateAction, Omit<Refund["UpdateOperationData"], "withdraw">, Refund["Filter"]>)[];
|
|
withdrawTransfer$withdraw?: (OakOperation<"create", Omit<WithdrawTransfer["CreateOperationData"], "withdraw"> | Omit<WithdrawTransfer["CreateOperationData"], "withdraw">[]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, Omit<WithdrawTransfer["UpdateOperationData"], "withdraw">, WithdrawTransfer["Filter"]>)[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "withdraw"> | Omit<AccountOper["CreateOperationData"], "withdraw">[]>[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", Withdraw["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<Withdraw["CreateOperationData"]>>;
|
|
Create: Withdraw["CreateSingle"] | Withdraw["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWithdraw.OpSchema & {
|
|
account?: OakOperation<"create", Account["CreateOperationData"]> | OakOperation<BaseAccount.OpUpdateAction, Account["UpdateOperationData"], Account["Filter"]> | OakOperation<"remove", Account["RemoveOperationData"], Account["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
refund$withdraw?: (OakOperation<"create", Omit<Refund["CreateOperationData"], "withdraw"> | Omit<Refund["CreateOperationData"], "withdraw">[]> | OakOperation<BaseRefund.OpUpdateAction, Omit<Refund["UpdateOperationData"], "withdraw">, Refund["Filter"]> | OakOperation<"remove", Refund["RemoveOperationData"], Refund["Filter"]>)[];
|
|
withdrawTransfer$withdraw?: (OakOperation<"create", Omit<WithdrawTransfer["CreateOperationData"], "withdraw"> | Omit<WithdrawTransfer["CreateOperationData"], "withdraw">[]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, Omit<WithdrawTransfer["UpdateOperationData"], "withdraw">, WithdrawTransfer["Filter"]> | OakOperation<"remove", WithdrawTransfer["RemoveOperationData"], WithdrawTransfer["Filter"]>)[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "withdraw"> | Omit<AccountOper["CreateOperationData"], "withdraw">[]>[];
|
|
}>;
|
|
Update: OakOperation<BaseWithdraw.OpUpdateAction, Withdraw["UpdateOperationData"], Withdraw["Filter"], Withdraw["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", Withdraw["RemoveOperationData"], Withdraw["Filter"], Withdraw["Sorter"]>;
|
|
Operation: Withdraw["Create"] | Withdraw["Update"] | Withdraw["Remove"];
|
|
};
|
|
export type WithdrawAccount = {
|
|
OpSchema: BaseWithdrawAccount.OpSchema;
|
|
Action: BaseWithdrawAccount.OpAction;
|
|
Schema: BaseWithdrawAccount.OpSchema & {
|
|
ofSystem: System["Schema"];
|
|
channel: WithdrawChannel["Schema"];
|
|
system?: System["Schema"];
|
|
user?: User["Schema"];
|
|
withdrawTransfer$withdrawAccount?: Array<Omit<WithdrawTransfer["Schema"], "withdrawAccount">>;
|
|
withdrawTransfer$withdrawAccount$$aggr?: AggregationResult<Omit<WithdrawTransfer["Schema"], "withdrawAccount">>;
|
|
};
|
|
Projection: BaseWithdrawAccount.OpProjection & {
|
|
ofSystem?: System["Projection"];
|
|
channel?: WithdrawChannel["Projection"];
|
|
system?: System["Projection"];
|
|
user?: User["Projection"];
|
|
withdrawTransfer$withdrawAccount?: OakSelection<"select", Omit<WithdrawTransfer["Projection"], "withdrawAccount">, Omit<WithdrawTransfer["Filter"], "withdrawAccount">, WithdrawTransfer["Sorter"]> & {
|
|
$entity: "withdrawTransfer";
|
|
};
|
|
withdrawTransfer$withdrawAccount$$aggr?: DeduceAggregation<Omit<WithdrawTransfer["Projection"], "withdrawAccount">, Omit<WithdrawTransfer["Filter"], "withdrawAccount">, WithdrawTransfer["Sorter"]> & {
|
|
$entity: "withdrawTransfer";
|
|
};
|
|
};
|
|
FilterUnit: BaseWithdrawAccount.OpFilter & {
|
|
ofSystem: MakeFilter<System["FilterUnit"]>;
|
|
channel: MakeFilter<WithdrawChannel["FilterUnit"]>;
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
user: MakeFilter<User["FilterUnit"]>;
|
|
withdrawTransfer$withdrawAccount: MakeFilter<Omit<WithdrawTransfer["FilterUnit"], "withdrawAccount">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WithdrawAccount["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWithdrawAccount.OpSortAttr | {
|
|
ofSystem: System["SortAttr"];
|
|
channel: WithdrawChannel["SortAttr"];
|
|
system: System["SortAttr"];
|
|
user: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WithdrawAccount["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WithdrawAccount["SortNode"][];
|
|
Selection: OakSelection<"select", WithdrawAccount["Projection"], WithdrawAccount["Filter"], WithdrawAccount["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WithdrawAccount["Projection"], WithdrawAccount["Filter"], WithdrawAccount["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWithdrawAccount.OpSchema & {
|
|
ofSystem?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
channel?: OakOperation<"create", WithdrawChannel["CreateOperationData"]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, WithdrawChannel["UpdateOperationData"], WithdrawChannel["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
withdrawTransfer$withdrawAccount?: (OakOperation<"create", Omit<WithdrawTransfer["CreateOperationData"], "withdrawAccount"> | Omit<WithdrawTransfer["CreateOperationData"], "withdrawAccount">[]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, Omit<WithdrawTransfer["UpdateOperationData"], "withdrawAccount">, WithdrawTransfer["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WithdrawAccount["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WithdrawAccount["CreateOperationData"]>>;
|
|
Create: WithdrawAccount["CreateSingle"] | WithdrawAccount["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWithdrawAccount.OpSchema & {
|
|
ofSystem?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
channel?: OakOperation<"create", WithdrawChannel["CreateOperationData"]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, WithdrawChannel["UpdateOperationData"], WithdrawChannel["Filter"]> | OakOperation<"remove", WithdrawChannel["RemoveOperationData"], WithdrawChannel["Filter"]>;
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
user?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
withdrawTransfer$withdrawAccount?: (OakOperation<"create", Omit<WithdrawTransfer["CreateOperationData"], "withdrawAccount"> | Omit<WithdrawTransfer["CreateOperationData"], "withdrawAccount">[]> | OakOperation<BaseWithdrawTransfer.OpUpdateAction, Omit<WithdrawTransfer["UpdateOperationData"], "withdrawAccount">, WithdrawTransfer["Filter"]> | OakOperation<"remove", WithdrawTransfer["RemoveOperationData"], WithdrawTransfer["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWithdrawAccount.OpUpdateAction, WithdrawAccount["UpdateOperationData"], WithdrawAccount["Filter"], WithdrawAccount["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WithdrawAccount["RemoveOperationData"], WithdrawAccount["Filter"], WithdrawAccount["Sorter"]>;
|
|
Operation: WithdrawAccount["Create"] | WithdrawAccount["Update"] | WithdrawAccount["Remove"];
|
|
};
|
|
export type WithdrawChannel = {
|
|
OpSchema: BaseWithdrawChannel.OpSchema;
|
|
Action: BaseWithdrawChannel.OpAction;
|
|
Schema: BaseWithdrawChannel.OpSchema & {
|
|
system: System["Schema"];
|
|
apAccount?: ApAccount["Schema"];
|
|
offlineAccount?: OfflineAccount["Schema"];
|
|
wpAccount?: WpAccount["Schema"];
|
|
withdrawAccount$channel?: Array<Omit<WithdrawAccount["Schema"], "channel">>;
|
|
withdrawAccount$channel$$aggr?: AggregationResult<Omit<WithdrawAccount["Schema"], "channel">>;
|
|
};
|
|
Projection: BaseWithdrawChannel.OpProjection & {
|
|
system?: System["Projection"];
|
|
apAccount?: ApAccount["Projection"];
|
|
offlineAccount?: OfflineAccount["Projection"];
|
|
wpAccount?: WpAccount["Projection"];
|
|
withdrawAccount$channel?: OakSelection<"select", Omit<WithdrawAccount["Projection"], "withdrawChannel">, Omit<WithdrawAccount["Filter"], "withdrawChannel">, WithdrawAccount["Sorter"]> & {
|
|
$entity: "withdrawAccount";
|
|
};
|
|
withdrawAccount$channel$$aggr?: DeduceAggregation<Omit<WithdrawAccount["Projection"], "withdrawChannel">, Omit<WithdrawAccount["Filter"], "withdrawChannel">, WithdrawAccount["Sorter"]> & {
|
|
$entity: "withdrawAccount";
|
|
};
|
|
};
|
|
FilterUnit: BaseWithdrawChannel.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
apAccount: MakeFilter<ApAccount["FilterUnit"]>;
|
|
offlineAccount: MakeFilter<OfflineAccount["FilterUnit"]>;
|
|
wpAccount: MakeFilter<WpAccount["FilterUnit"]>;
|
|
withdrawAccount$channel: MakeFilter<Omit<WithdrawAccount["FilterUnit"], "channel">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WithdrawChannel["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWithdrawChannel.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
apAccount: ApAccount["SortAttr"];
|
|
offlineAccount: OfflineAccount["SortAttr"];
|
|
wpAccount: WpAccount["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WithdrawChannel["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WithdrawChannel["SortNode"][];
|
|
Selection: OakSelection<"select", WithdrawChannel["Projection"], WithdrawChannel["Filter"], WithdrawChannel["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WithdrawChannel["Projection"], WithdrawChannel["Filter"], WithdrawChannel["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWithdrawChannel.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
apAccount?: OakOperation<"create", ApAccount["CreateOperationData"]> | OakOperation<BaseApAccount.OpUpdateAction, ApAccount["UpdateOperationData"], ApAccount["Filter"]>;
|
|
offlineAccount?: OakOperation<"create", OfflineAccount["CreateOperationData"]> | OakOperation<BaseOfflineAccount.OpUpdateAction, OfflineAccount["UpdateOperationData"], OfflineAccount["Filter"]>;
|
|
wpAccount?: OakOperation<"create", WpAccount["CreateOperationData"]> | OakOperation<BaseWpAccount.OpUpdateAction, WpAccount["UpdateOperationData"], WpAccount["Filter"]>;
|
|
withdrawAccount$channel?: (OakOperation<"create", Omit<WithdrawAccount["CreateOperationData"], "channel"> | Omit<WithdrawAccount["CreateOperationData"], "channel">[]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, Omit<WithdrawAccount["UpdateOperationData"], "channel">, WithdrawAccount["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WithdrawChannel["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WithdrawChannel["CreateOperationData"]>>;
|
|
Create: WithdrawChannel["CreateSingle"] | WithdrawChannel["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWithdrawChannel.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
apAccount?: OakOperation<"create", ApAccount["CreateOperationData"]> | OakOperation<BaseApAccount.OpUpdateAction, ApAccount["UpdateOperationData"], ApAccount["Filter"]> | OakOperation<"remove", ApAccount["RemoveOperationData"], ApAccount["Filter"]>;
|
|
offlineAccount?: OakOperation<"create", OfflineAccount["CreateOperationData"]> | OakOperation<BaseOfflineAccount.OpUpdateAction, OfflineAccount["UpdateOperationData"], OfflineAccount["Filter"]> | OakOperation<"remove", OfflineAccount["RemoveOperationData"], OfflineAccount["Filter"]>;
|
|
wpAccount?: OakOperation<"create", WpAccount["CreateOperationData"]> | OakOperation<BaseWpAccount.OpUpdateAction, WpAccount["UpdateOperationData"], WpAccount["Filter"]> | OakOperation<"remove", WpAccount["RemoveOperationData"], WpAccount["Filter"]>;
|
|
withdrawAccount$channel?: (OakOperation<"create", Omit<WithdrawAccount["CreateOperationData"], "channel"> | Omit<WithdrawAccount["CreateOperationData"], "channel">[]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, Omit<WithdrawAccount["UpdateOperationData"], "channel">, WithdrawAccount["Filter"]> | OakOperation<"remove", WithdrawAccount["RemoveOperationData"], WithdrawAccount["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWithdrawChannel.OpUpdateAction, WithdrawChannel["UpdateOperationData"], WithdrawChannel["Filter"], WithdrawChannel["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WithdrawChannel["RemoveOperationData"], WithdrawChannel["Filter"], WithdrawChannel["Sorter"]>;
|
|
Operation: WithdrawChannel["Create"] | WithdrawChannel["Update"] | WithdrawChannel["Remove"];
|
|
};
|
|
export type WithdrawTransfer = {
|
|
OpSchema: BaseWithdrawTransfer.OpSchema;
|
|
Action: BaseWithdrawTransfer.OpAction;
|
|
Schema: BaseWithdrawTransfer.OpSchema & {
|
|
withdraw: Withdraw["Schema"];
|
|
withdrawAccount: WithdrawAccount["Schema"];
|
|
operator?: User["Schema"];
|
|
creator: User["Schema"];
|
|
sysAccountOper$withdrawTransfer?: Array<Omit<SysAccountOper["Schema"], "withdrawTransfer">>;
|
|
accountOper$entity?: Array<Omit<AccountOper["Schema"], "entity">>;
|
|
sysAccountOper$withdrawTransfer$$aggr?: AggregationResult<Omit<SysAccountOper["Schema"], "withdrawTransfer">>;
|
|
accountOper$entity$$aggr?: AggregationResult<Omit<AccountOper["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseWithdrawTransfer.OpProjection & {
|
|
withdraw?: Withdraw["Projection"];
|
|
withdrawAccount?: WithdrawAccount["Projection"];
|
|
operator?: User["Projection"];
|
|
creator?: User["Projection"];
|
|
sysAccountOper$withdrawTransfer?: OakSelection<"select", Omit<SysAccountOper["Projection"], "withdrawTransfer">, Omit<SysAccountOper["Filter"], "withdrawTransfer">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
sysAccountOper$withdrawTransfer$$aggr?: DeduceAggregation<Omit<SysAccountOper["Projection"], "withdrawTransfer">, Omit<SysAccountOper["Filter"], "withdrawTransfer">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
accountOper$entity?: OakSelection<"select", Omit<AccountOper["Projection"], "withdrawTransfer">, Omit<AccountOper["Filter"], "withdrawTransfer">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
accountOper$entity$$aggr?: DeduceAggregation<Omit<AccountOper["Projection"], "withdrawTransfer">, Omit<AccountOper["Filter"], "withdrawTransfer">, AccountOper["Sorter"]> & {
|
|
$entity: "accountOper";
|
|
};
|
|
};
|
|
FilterUnit: BaseWithdrawTransfer.OpFilter & {
|
|
withdraw: MakeFilter<Withdraw["FilterUnit"]>;
|
|
withdrawAccount: MakeFilter<WithdrawAccount["FilterUnit"]>;
|
|
operator: MakeFilter<User["FilterUnit"]>;
|
|
creator: MakeFilter<User["FilterUnit"]>;
|
|
sysAccountOper$withdrawTransfer: MakeFilter<Omit<SysAccountOper["FilterUnit"], "withdrawTransfer">> & SubQueryPredicateMetadata;
|
|
accountOper$entity: MakeFilter<Omit<AccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WithdrawTransfer["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWithdrawTransfer.OpSortAttr | {
|
|
withdraw: Withdraw["SortAttr"];
|
|
withdrawAccount: WithdrawAccount["SortAttr"];
|
|
operator: User["SortAttr"];
|
|
creator: User["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WithdrawTransfer["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WithdrawTransfer["SortNode"][];
|
|
Selection: OakSelection<"select", WithdrawTransfer["Projection"], WithdrawTransfer["Filter"], WithdrawTransfer["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WithdrawTransfer["Projection"], WithdrawTransfer["Filter"], WithdrawTransfer["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWithdrawTransfer.OpSchema & {
|
|
withdraw?: OakOperation<"create", Withdraw["CreateOperationData"]> | OakOperation<BaseWithdraw.OpUpdateAction, Withdraw["UpdateOperationData"], Withdraw["Filter"]>;
|
|
withdrawAccount?: OakOperation<"create", WithdrawAccount["CreateOperationData"]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, WithdrawAccount["UpdateOperationData"], WithdrawAccount["Filter"]>;
|
|
operator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]>;
|
|
sysAccountOper$withdrawTransfer?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "withdrawTransfer"> | Omit<SysAccountOper["CreateOperationData"], "withdrawTransfer">[]>[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "withdrawTransfer"> | Omit<AccountOper["CreateOperationData"], "withdrawTransfer">[]>[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WithdrawTransfer["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WithdrawTransfer["CreateOperationData"]>>;
|
|
Create: WithdrawTransfer["CreateSingle"] | WithdrawTransfer["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWithdrawTransfer.OpSchema & {
|
|
withdraw?: OakOperation<"create", Withdraw["CreateOperationData"]> | OakOperation<BaseWithdraw.OpUpdateAction, Withdraw["UpdateOperationData"], Withdraw["Filter"]> | OakOperation<"remove", Withdraw["RemoveOperationData"], Withdraw["Filter"]>;
|
|
withdrawAccount?: OakOperation<"create", WithdrawAccount["CreateOperationData"]> | OakOperation<BaseWithdrawAccount.OpUpdateAction, WithdrawAccount["UpdateOperationData"], WithdrawAccount["Filter"]> | OakOperation<"remove", WithdrawAccount["RemoveOperationData"], WithdrawAccount["Filter"]>;
|
|
operator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
creator?: OakOperation<"create", User["CreateOperationData"]> | OakOperation<BaseUser.OpUpdateAction, User["UpdateOperationData"], User["Filter"]> | OakOperation<"remove", User["RemoveOperationData"], User["Filter"]>;
|
|
sysAccountOper$withdrawTransfer?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "withdrawTransfer"> | Omit<SysAccountOper["CreateOperationData"], "withdrawTransfer">[]>[];
|
|
accountOper$entity?: OakOperation<"create", Omit<AccountOper["CreateOperationData"], "withdrawTransfer"> | Omit<AccountOper["CreateOperationData"], "withdrawTransfer">[]>[];
|
|
}>;
|
|
Update: OakOperation<BaseWithdrawTransfer.OpUpdateAction, WithdrawTransfer["UpdateOperationData"], WithdrawTransfer["Filter"], WithdrawTransfer["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WithdrawTransfer["RemoveOperationData"], WithdrawTransfer["Filter"], WithdrawTransfer["Sorter"]>;
|
|
Operation: WithdrawTransfer["Create"] | WithdrawTransfer["Update"] | WithdrawTransfer["Remove"];
|
|
};
|
|
export type WpAccount = {
|
|
OpSchema: BaseWpAccount.OpSchema;
|
|
Action: BaseWpAccount.OpAction;
|
|
Schema: BaseWpAccount.OpSchema & {
|
|
system: System["Schema"];
|
|
wechatPay: WechatPay["Schema"];
|
|
wpProduct$wpAccount?: Array<Omit<WpProduct["Schema"], "wpAccount">>;
|
|
sysAccountOper$entity?: Array<Omit<SysAccountOper["Schema"], "entity">>;
|
|
withdrawChannel$entity?: Array<Omit<WithdrawChannel["Schema"], "entity">>;
|
|
wpProduct$wpAccount$$aggr?: AggregationResult<Omit<WpProduct["Schema"], "wpAccount">>;
|
|
sysAccountOper$entity$$aggr?: AggregationResult<Omit<SysAccountOper["Schema"], "entity">>;
|
|
withdrawChannel$entity$$aggr?: AggregationResult<Omit<WithdrawChannel["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseWpAccount.OpProjection & {
|
|
system?: System["Projection"];
|
|
wechatPay?: WechatPay["Projection"];
|
|
wpProduct$wpAccount?: OakSelection<"select", Omit<WpProduct["Projection"], "wpAccount">, Omit<WpProduct["Filter"], "wpAccount">, WpProduct["Sorter"]> & {
|
|
$entity: "wpProduct";
|
|
};
|
|
wpProduct$wpAccount$$aggr?: DeduceAggregation<Omit<WpProduct["Projection"], "wpAccount">, Omit<WpProduct["Filter"], "wpAccount">, WpProduct["Sorter"]> & {
|
|
$entity: "wpProduct";
|
|
};
|
|
sysAccountOper$entity?: OakSelection<"select", Omit<SysAccountOper["Projection"], "wpAccount">, Omit<SysAccountOper["Filter"], "wpAccount">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
sysAccountOper$entity$$aggr?: DeduceAggregation<Omit<SysAccountOper["Projection"], "wpAccount">, Omit<SysAccountOper["Filter"], "wpAccount">, SysAccountOper["Sorter"]> & {
|
|
$entity: "sysAccountOper";
|
|
};
|
|
withdrawChannel$entity?: OakSelection<"select", Omit<WithdrawChannel["Projection"], "wpAccount">, Omit<WithdrawChannel["Filter"], "wpAccount">, WithdrawChannel["Sorter"]> & {
|
|
$entity: "withdrawChannel";
|
|
};
|
|
withdrawChannel$entity$$aggr?: DeduceAggregation<Omit<WithdrawChannel["Projection"], "wpAccount">, Omit<WithdrawChannel["Filter"], "wpAccount">, WithdrawChannel["Sorter"]> & {
|
|
$entity: "withdrawChannel";
|
|
};
|
|
};
|
|
FilterUnit: BaseWpAccount.OpFilter & {
|
|
system: MakeFilter<System["FilterUnit"]>;
|
|
wechatPay: MakeFilter<WechatPay["FilterUnit"]>;
|
|
wpProduct$wpAccount: MakeFilter<Omit<WpProduct["FilterUnit"], "wpAccount">> & SubQueryPredicateMetadata;
|
|
sysAccountOper$entity: MakeFilter<Omit<SysAccountOper["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
withdrawChannel$entity: MakeFilter<Omit<WithdrawChannel["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WpAccount["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWpAccount.OpSortAttr | {
|
|
system: System["SortAttr"];
|
|
wechatPay: WechatPay["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WpAccount["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WpAccount["SortNode"][];
|
|
Selection: OakSelection<"select", WpAccount["Projection"], WpAccount["Filter"], WpAccount["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WpAccount["Projection"], WpAccount["Filter"], WpAccount["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWpAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]>;
|
|
wechatPay?: OakOperation<"create", WechatPay["CreateOperationData"]> | OakOperation<BaseWechatPay.OpUpdateAction, WechatPay["UpdateOperationData"], WechatPay["Filter"]>;
|
|
wpProduct$wpAccount?: (OakOperation<"create", Omit<WpProduct["CreateOperationData"], "wpAccount"> | Omit<WpProduct["CreateOperationData"], "wpAccount">[]> | OakOperation<BaseWpProduct.OpUpdateAction, Omit<WpProduct["UpdateOperationData"], "wpAccount">, WpProduct["Filter"]>)[];
|
|
sysAccountOper$entity?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "wpAccount"> | Omit<SysAccountOper["CreateOperationData"], "wpAccount">[]>[];
|
|
withdrawChannel$entity?: (OakOperation<"create", Omit<WithdrawChannel["CreateOperationData"], "wpAccount"> | Omit<WithdrawChannel["CreateOperationData"], "wpAccount">[]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, Omit<WithdrawChannel["UpdateOperationData"], "wpAccount">, WithdrawChannel["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WpAccount["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WpAccount["CreateOperationData"]>>;
|
|
Create: WpAccount["CreateSingle"] | WpAccount["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWpAccount.OpSchema & {
|
|
system?: OakOperation<"create", System["CreateOperationData"]> | OakOperation<BaseSystem.OpUpdateAction, System["UpdateOperationData"], System["Filter"]> | OakOperation<"remove", System["RemoveOperationData"], System["Filter"]>;
|
|
wechatPay?: OakOperation<"create", WechatPay["CreateOperationData"]> | OakOperation<BaseWechatPay.OpUpdateAction, WechatPay["UpdateOperationData"], WechatPay["Filter"]> | OakOperation<"remove", WechatPay["RemoveOperationData"], WechatPay["Filter"]>;
|
|
wpProduct$wpAccount?: (OakOperation<"create", Omit<WpProduct["CreateOperationData"], "wpAccount"> | Omit<WpProduct["CreateOperationData"], "wpAccount">[]> | OakOperation<BaseWpProduct.OpUpdateAction, Omit<WpProduct["UpdateOperationData"], "wpAccount">, WpProduct["Filter"]> | OakOperation<"remove", WpProduct["RemoveOperationData"], WpProduct["Filter"]>)[];
|
|
sysAccountOper$entity?: OakOperation<"create", Omit<SysAccountOper["CreateOperationData"], "wpAccount"> | Omit<SysAccountOper["CreateOperationData"], "wpAccount">[]>[];
|
|
withdrawChannel$entity?: (OakOperation<"create", Omit<WithdrawChannel["CreateOperationData"], "wpAccount"> | Omit<WithdrawChannel["CreateOperationData"], "wpAccount">[]> | OakOperation<BaseWithdrawChannel.OpUpdateAction, Omit<WithdrawChannel["UpdateOperationData"], "wpAccount">, WithdrawChannel["Filter"]> | OakOperation<"remove", WithdrawChannel["RemoveOperationData"], WithdrawChannel["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWpAccount.OpUpdateAction, WpAccount["UpdateOperationData"], WpAccount["Filter"], WpAccount["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WpAccount["RemoveOperationData"], WpAccount["Filter"], WpAccount["Sorter"]>;
|
|
Operation: WpAccount["Create"] | WpAccount["Update"] | WpAccount["Remove"];
|
|
};
|
|
export type WpProduct = {
|
|
OpSchema: BaseWpProduct.OpSchema;
|
|
Action: BaseWpProduct.OpAction;
|
|
Schema: BaseWpProduct.OpSchema & {
|
|
application: Application["Schema"];
|
|
wpAccount: WpAccount["Schema"];
|
|
pay$entity?: Array<Omit<Pay["Schema"], "entity">>;
|
|
pay$entity$$aggr?: AggregationResult<Omit<Pay["Schema"], "entity">>;
|
|
};
|
|
Projection: BaseWpProduct.OpProjection & {
|
|
application?: Application["Projection"];
|
|
wpAccount?: WpAccount["Projection"];
|
|
pay$entity?: OakSelection<"select", Omit<Pay["Projection"], "wpProduct">, Omit<Pay["Filter"], "wpProduct">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
pay$entity$$aggr?: DeduceAggregation<Omit<Pay["Projection"], "wpProduct">, Omit<Pay["Filter"], "wpProduct">, Pay["Sorter"]> & {
|
|
$entity: "pay";
|
|
};
|
|
};
|
|
FilterUnit: BaseWpProduct.OpFilter & {
|
|
application: MakeFilter<Application["FilterUnit"]>;
|
|
wpAccount: MakeFilter<WpAccount["FilterUnit"]>;
|
|
pay$entity: MakeFilter<Omit<Pay["FilterUnit"], "entity">> & SubQueryPredicateMetadata;
|
|
};
|
|
Filter: MakeFilter<WpProduct["FilterUnit"]>;
|
|
SortAttr: Partial<BaseWpProduct.OpSortAttr | {
|
|
application: Application["SortAttr"];
|
|
wpAccount: WpAccount["SortAttr"];
|
|
}>;
|
|
SortNode: {
|
|
$attr: WpProduct["SortAttr"];
|
|
$direction?: "asc" | "desc";
|
|
};
|
|
Sorter: WpProduct["SortNode"][];
|
|
Selection: OakSelection<"select", WpProduct["Projection"], WpProduct["Filter"], WpProduct["Sorter"]>;
|
|
Aggregation: DeduceAggregation<WpProduct["Projection"], WpProduct["Filter"], WpProduct["Sorter"]>;
|
|
CreateOperationData: FormCreateData<BaseWpProduct.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]>;
|
|
wpAccount?: OakOperation<"create", WpAccount["CreateOperationData"]> | OakOperation<BaseWpAccount.OpUpdateAction, WpAccount["UpdateOperationData"], WpAccount["Filter"]>;
|
|
pay$entity?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "wpProduct"> | Omit<Pay["CreateOperationData"], "wpProduct">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "wpProduct">, Pay["Filter"]>)[];
|
|
}>;
|
|
CreateSingle: OakOperation<"create", WpProduct["CreateOperationData"]>;
|
|
CreateMulti: OakOperation<"create", Array<WpProduct["CreateOperationData"]>>;
|
|
Create: WpProduct["CreateSingle"] | WpProduct["CreateMulti"];
|
|
UpdateOperationData: FormUpdateData<BaseWpProduct.OpSchema & {
|
|
application?: OakOperation<"create", Application["CreateOperationData"]> | OakOperation<BaseApplication.OpUpdateAction, Application["UpdateOperationData"], Application["Filter"]> | OakOperation<"remove", Application["RemoveOperationData"], Application["Filter"]>;
|
|
wpAccount?: OakOperation<"create", WpAccount["CreateOperationData"]> | OakOperation<BaseWpAccount.OpUpdateAction, WpAccount["UpdateOperationData"], WpAccount["Filter"]> | OakOperation<"remove", WpAccount["RemoveOperationData"], WpAccount["Filter"]>;
|
|
pay$entity?: (OakOperation<"create", Omit<Pay["CreateOperationData"], "wpProduct"> | Omit<Pay["CreateOperationData"], "wpProduct">[]> | OakOperation<BasePay.OpUpdateAction, Omit<Pay["UpdateOperationData"], "wpProduct">, Pay["Filter"]> | OakOperation<"remove", Pay["RemoveOperationData"], Pay["Filter"]>)[];
|
|
}>;
|
|
Update: OakOperation<BaseWpProduct.OpUpdateAction, WpProduct["UpdateOperationData"], WpProduct["Filter"], WpProduct["Sorter"]>;
|
|
RemoveOperationData: {};
|
|
Remove: OakOperation<"remove", WpProduct["RemoveOperationData"], WpProduct["Filter"], WpProduct["Sorter"]>;
|
|
Operation: WpProduct["Create"] | WpProduct["Update"] | WpProduct["Remove"];
|
|
};
|
|
export type EntityDict = {
|
|
actionAuth: ActionAuth;
|
|
i18n: I18n;
|
|
log: Log;
|
|
modi: Modi;
|
|
modiEntity: ModiEntity;
|
|
oper: Oper;
|
|
operEntity: OperEntity;
|
|
path: Path;
|
|
relation: Relation;
|
|
relationAuth: RelationAuth;
|
|
user: User;
|
|
userEntityClaim: UserEntityClaim;
|
|
userEntityGrant: UserEntityGrant;
|
|
userRelation: UserRelation;
|
|
address: Address;
|
|
application: Application;
|
|
applicationPassport: ApplicationPassport;
|
|
area: Area;
|
|
article: Article;
|
|
articleMenu: ArticleMenu;
|
|
captcha: Captcha;
|
|
changePasswordTemp: ChangePasswordTemp;
|
|
domain: Domain;
|
|
email: Email;
|
|
extraFile: ExtraFile;
|
|
livestream: Livestream;
|
|
loginName: LoginName;
|
|
message: Message;
|
|
messageSystem: MessageSystem;
|
|
messageType: MessageType;
|
|
messageTypeSmsTemplate: MessageTypeSmsTemplate;
|
|
messageTypeTemplate: MessageTypeTemplate;
|
|
mobile: Mobile;
|
|
notification: Notification;
|
|
oauthApplication: OauthApplication;
|
|
oauthAuthorizationCode: OauthAuthorizationCode;
|
|
oauthProvider: OauthProvider;
|
|
oauthState: OauthState;
|
|
oauthToken: OauthToken;
|
|
oauthUser: OauthUser;
|
|
oauthUserAuthorization: OauthUserAuthorization;
|
|
parasite: Parasite;
|
|
passport: Passport;
|
|
platform: Platform;
|
|
readRemark: ReadRemark;
|
|
session: Session;
|
|
sessionMessage: SessionMessage;
|
|
smsTemplate: SmsTemplate;
|
|
station: Station;
|
|
subscription: Subscription;
|
|
subway: Subway;
|
|
subwayStation: SubwayStation;
|
|
system: System;
|
|
toDo: ToDo;
|
|
token: Token;
|
|
userSystem: UserSystem;
|
|
userWechatPublicTag: UserWechatPublicTag;
|
|
wechatLogin: WechatLogin;
|
|
wechatMenu: WechatMenu;
|
|
wechatMpJump: WechatMpJump;
|
|
wechatPublicAutoReply: WechatPublicAutoReply;
|
|
wechatPublicTag: WechatPublicTag;
|
|
wechatQrCode: WechatQrCode;
|
|
wechatTemplate: WechatTemplate;
|
|
wechatUser: WechatUser;
|
|
abstractPayAccount: AbstractPayAccount;
|
|
abstractPayProduct: AbstractPayProduct;
|
|
abstractShipAccount: AbstractShipAccount;
|
|
account: Account;
|
|
accountOper: AccountOper;
|
|
aliPay: AliPay;
|
|
apAccount: ApAccount;
|
|
apProduct: ApProduct;
|
|
deposit: Deposit;
|
|
offlineAccount: OfflineAccount;
|
|
order: Order;
|
|
pay: Pay;
|
|
refund: Refund;
|
|
settlement: Settlement;
|
|
settlePlan: SettlePlan;
|
|
ship: Ship;
|
|
shipCompany: ShipCompany;
|
|
shipOrder: ShipOrder;
|
|
shipService: ShipService;
|
|
shipServiceSystem: ShipServiceSystem;
|
|
sysAccountMove: SysAccountMove;
|
|
sysAccountOper: SysAccountOper;
|
|
wechatMpShip: WechatMpShip;
|
|
wechatPay: WechatPay;
|
|
withdraw: Withdraw;
|
|
withdrawAccount: WithdrawAccount;
|
|
withdrawChannel: WithdrawChannel;
|
|
withdrawTransfer: WithdrawTransfer;
|
|
wpAccount: WpAccount;
|
|
wpProduct: WpProduct;
|
|
};
|