import { Instance } from 'mobx-state-tree'; import type { IAnyModelType, IModelType } from 'mobx-state-tree/dist/types/complex-types/model'; import type { MSTGQLStore, Query } from 'mst-gql'; import { createNativeStackNavigator, NativeStackScreenProps } from '@react-navigation/native-stack'; import React, { Component, FC, ReactElement } from 'react'; import type { IAnyType } from 'mobx-state-tree/dist/internal'; import type { IOptionalIType } from 'mobx-state-tree/dist/types/utility-types/optional'; import type { StyledProps } from 'native-base/src/theme/types'; import type { GestureResponderEvent } from 'react-native'; import type BaseSchema from 'yup/lib/schema'; import type { ObjectSchema } from 'yup'; export declare enum QueryState { PENDING = "PENDING", DONE = "DONE", ERROR = "ERROR" } export declare enum AssocSelectionType { NONE = "NONE", SINGLE = "SINGLE", MULTIPLE = "MULTIPLE" } /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ export declare function createEntityModel(modelConfig: EntityConfig): IModelType<{ currentPage: IOptionalIType, [undefined]>; pageSize: IOptionalIType, [undefined]>; count: import("mobx-state-tree").IMaybeNull>; joinFields: import("mobx-state-tree").IMaybeNull>; baseWhere: import("mobx-state-tree").IMaybeNull>; where: import("mobx-state-tree").IMaybeNull>; orderBy: IOptionalIType, [undefined]>; listQueryState: import("mobx-state-tree").IMaybeNull>; listQueryError: import("mobx-state-tree").IMaybe>; updateMutationState: import("mobx-state-tree").IMaybeNull>; updateMutationError: import("mobx-state-tree").IMaybeNull>; createMutationState: import("mobx-state-tree").IMaybeNull>; createMutationError: import("mobx-state-tree").IMaybeNull>; deleteMutationState: import("mobx-state-tree").IMaybeNull>; deleteMutationError: import("mobx-state-tree").IMaybeNull>; associateMutationState: import("mobx-state-tree").IMaybeNull>; associateMutationError: import("mobx-state-tree").IMaybeNull>; canUnassociateAny: IOptionalIType, [undefined]>; unassociateMutationState: import("mobx-state-tree").IMaybeNull>; unassociateMutationError: import("mobx-state-tree").IMaybeNull>; pageResult: IOptionalIType>>, [undefined]>; editId: import("mobx-state-tree").IMaybeNull>; selectedId: import("mobx-state-tree").IMaybeNull>; defaultCreateFieldValues: import("mobx-state-tree").IMaybeNull>; defaultUpdateFieldValues: import("mobx-state-tree").IMaybeNull>; loadQueryState: import("mobx-state-tree").IMaybeNull>; loadQueryError: import("mobx-state-tree").IMaybeNull>; loadedItem: import("mobx-state-tree").IMaybeNull>>; selectedItems: IOptionalIType>>, [undefined]>; createdItem: import("mobx-state-tree").IMaybeNull>>; updatedItem: import("mobx-state-tree").IMaybeNull>>; relations: IOptionalIType, [undefined]>; }, { getParentField(field: string): any; } & { afterCreate: () => void; reset: () => void; } & { readonly numberOfPages: number; readonly gqlStore: GqlStoreType; /** * Calculates the final where condition from self.baseWhere and self.where */ readonly finalWhere: BoolExpType; } & { configureRelated(rootEntityModel: any, params: RouteConfig): void; readonly relatedFieldName: null; readonly rootEntityModel: null; readonly rootEntityModelName: null; createEntityNavigator(model: any): React.ComponentType<{}>; } & { /** * Internal. Calculate the number of all elements in list * Moved out of the ain actions so that it can be called as * yield self._count() otherwise typing of the model blows up */ _count(): Query; } & { readonly config: EntityConfig; setConfig(newConfig: EntityConfigAny): void; } & { setPageSize(pageSize: number): void; /** * Sets the query parameters for listing ServiceAccounts * @param where conditions for querying * @param orderBy sort specification for ordering result */ setQueryParams(where: BoolExpType | null, orderBy: OrderByType[] | null): void; setBaseQueryCondition(where: BoolExpType | null): void; /** * Internal. Set count of all elements we are about to display. * @param count */ _setCount(count: number | null): void; setListQueryState(state: QueryState, error?: string | undefined): void; setPageResult(pageResult: Array): void; reloadList(): void; setLoadedItem(item?: ModelType | undefined): void; addSelectedItem(item: ModelType): void; removeSelectedItem(item: ModelType): void; clearSlectedItems(): void; isSelectedItem(item: ModelType): any; setCreatedItem(item?: ModelType | undefined): void; setUpdatedItem(item?: ModelType | undefined): void; setEditId(id?: string | number | null): void; setSelectedId(id?: string | number | null): void; /** * List elements on the given page * @param page page to display */ list: (page: number) => Promise>; setLoadQueryState(state: QueryState, error?: string | null): void; load(id: string): Query; setDefaultCreateFieldValues(values: { [key: string]: any; }): void; setDefaultUpdateFieldValues(values: { [key: string]: any; }): void; setUpdateMutationState(state: QueryState, error?: string | null): void; update(params: UpdateParamType): Query; setCreateMutationState(state: QueryState, error?: string | null): void; create(params: CreateParamType): Query; setAssociateMutationState(state: QueryState, error?: string | null): void; associate(relation: any, associateIds: string[] | number[]): any; setCanUnassociateAny(flag: boolean): void; setUnassociateMutationState(state: QueryState, error?: string | null): void; unassociate(relation: any, associateIds: string[] | number[]): any; setDeleteMutationState(state: QueryState, error?: string | null): void; delete(items: ModelType[]): Query; setJoinFields(joinFields: { [key: string]: any; }): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>; /** * Convenience function to declare types.optional(someType {}) --> initialized(someType) * @param type */ export declare function initialized(type: IT): IOptionalIType; export interface RelationModelConfig { fieldName: string; fieldModel: EntityModel; fieldModelConfigurator: (fieldModel: EntityModelType, rootEntityModel: EntityModelType, params: RouteConfig) => void; assocModel?: EntityModel; assocModelConfigurator?: (assocModel: EntityModelType, rootEntityModel: EntityModelType, params: RouteConfig) => void; associate?: (gqlStore: StoreType, loadedItem: any, field: string, associatedIds: string[]) => Query; unassociate?: (gqlStore: StoreType, loadedItem: any, field: string, associatedIds: string[]) => Query; canUnassociate?: (item: any, viewType: ViewType, fieldModel: EntityModelType) => boolean; allowCreatingNewRelated?: boolean; assocSelectionType?: AssocSelectionType; prepareNew?: (gqlStore: StoreType, rootEntityModel: EntityModelType, model: EntityModelType, formValues: any, field: string) => void; createNew?: (gqlStore: StoreType, rootEntityModel: EntityModelType, model: EntityModelType, formValues: any, field: string) => Query; } /** * Defines a RelationModel for a specific field of a root model. * @param args relation arguments, see below: * @param args.fieldName name of the relationship field * @param args.fieldModel model to display currently set related values * @param args.fieldModelConfigurator function to configure the fieldModel instance at runtime * @param args.assocModel the model used for displaying entities which ar associable for this relation. It must be the same type model as fieldModel * but configured for displaying associaable entities. * @param args.assocModelConfigurator function to configure the assocModel instance at runtime * @param args.associate function to do the association between the entities selected in assocModel and the root model * @param args.associate function to do the unassociation between the entities selected in assocModel and the root model * @param args.allowCreatingNewRelated if true, displays a form for creating a new associable entity and assign it with the root model. Default: false * @param args.assocSelectionType how many items can be associated from the assocModel? Default to NONE, in which case specifying assocModel is * not necessary * @param args.prepareNew called to allow making changed to the form values before doing the actual mutation * @param args.prepareNew Not supported yet. Would be used to execute creation mutation in its own. This is now done by EntityForm using * model.create(). A createNew() implementation should eventually call rootModel.create() as well. */ export declare function relation(rootEntityModel: EntityModel, args: RelationModelConfig): IOptionalIType>; fieldName: IOptionalIType, [undefined]>; fieldModel: IOptionalIType, [undefined]>; pageSize: IOptionalIType, [undefined]>; count: import("mobx-state-tree").IMaybeNull>; joinFields: import("mobx-state-tree").IMaybeNull>; baseWhere: import("mobx-state-tree").IMaybeNull>; where: import("mobx-state-tree").IMaybeNull>; orderBy: IOptionalIType, [undefined]>; listQueryState: import("mobx-state-tree").IMaybeNull>; listQueryError: import("mobx-state-tree").IMaybe>; updateMutationState: import("mobx-state-tree").IMaybeNull>; updateMutationError: import("mobx-state-tree").IMaybeNull>; createMutationState: import("mobx-state-tree").IMaybeNull>; createMutationError: import("mobx-state-tree").IMaybeNull>; deleteMutationState: import("mobx-state-tree").IMaybeNull>; deleteMutationError: import("mobx-state-tree").IMaybeNull>; associateMutationState: import("mobx-state-tree").IMaybeNull>; associateMutationError: import("mobx-state-tree").IMaybeNull>; canUnassociateAny: IOptionalIType, [undefined]>; unassociateMutationState: import("mobx-state-tree").IMaybeNull>; unassociateMutationError: import("mobx-state-tree").IMaybeNull>; pageResult: IOptionalIType>>, [undefined]>; editId: import("mobx-state-tree").IMaybeNull>; selectedId: import("mobx-state-tree").IMaybeNull>; defaultCreateFieldValues: import("mobx-state-tree").IMaybeNull>; defaultUpdateFieldValues: import("mobx-state-tree").IMaybeNull>; loadQueryState: import("mobx-state-tree").IMaybeNull>; loadQueryError: import("mobx-state-tree").IMaybeNull>; loadedItem: import("mobx-state-tree").IMaybeNull>>; selectedItems: IOptionalIType>>, [undefined]>; createdItem: import("mobx-state-tree").IMaybeNull>>; updatedItem: import("mobx-state-tree").IMaybeNull>>; relations: IOptionalIType, [undefined]>; }, never, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>, [undefined]>; }, { readonly allowCreatingNewRelated: boolean; readonly assocSelectionType: AssocSelectionType; readonly associate: ((gqlStore: { __queryCache: import("mobx-state-tree").IMSTMap> & import("mobx-state-tree").IStateTreeNode>, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; } & import("mobx-state-tree").IStateTreeNode>, [undefined]>; }, { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>, loadedItem: any, field: string, associatedIds: string[]) => Query) | undefined; readonly unassociate: ((gqlStore: { __queryCache: import("mobx-state-tree").IMSTMap> & import("mobx-state-tree").IStateTreeNode>, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; } & import("mobx-state-tree").IStateTreeNode>, [undefined]>; }, { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>, loadedItem: any, field: string, associatedIds: string[]) => Query) | undefined; readonly canUnassociate: ((item: any, viewType: ViewType, fieldModel: { currentPage: number; pageSize: number; count: number | null; joinFields: ({ [key: string]: any; } & import("mobx-state-tree").IStateTreeNode>>) | null; baseWhere: unknown; where: unknown; orderBy: unknown[] & import("mobx-state-tree").IStateTreeNode, [undefined]>>; listQueryState: QueryState | null; listQueryError: string | undefined; updateMutationState: QueryState | null; updateMutationError: string | null; createMutationState: QueryState | null; createMutationError: string | null; deleteMutationState: QueryState | null; deleteMutationError: string | null; associateMutationState: QueryState | null; associateMutationError: string | null; canUnassociateAny: boolean; unassociateMutationState: QueryState | null; unassociateMutationError: string | null; pageResult: import("mobx-state-tree").IMSTArray>> & import("mobx-state-tree").IStateTreeNode>>, [undefined]>>; editId: string | number | null; selectedId: string | number | null; defaultCreateFieldValues: ({ [key: string]: any; } & import("mobx-state-tree").IStateTreeNode>>) | null; defaultUpdateFieldValues: ({ [key: string]: any; } & import("mobx-state-tree").IStateTreeNode>>) | null; loadQueryState: QueryState | null; loadQueryError: string | null; loadedItem: any; selectedItems: import("mobx-state-tree").IMSTArray>> & import("mobx-state-tree").IStateTreeNode>>, [undefined]>>; createdItem: any; updatedItem: any; relations: {} & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree").IStateTreeNode, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { getParentField(field: string): any; } & { afterCreate: () => void; reset: () => void; } & { readonly numberOfPages: number; readonly gqlStore: { __queryCache: import("mobx-state-tree").IMSTMap> & import("mobx-state-tree").IStateTreeNode>, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; } & import("mobx-state-tree").IStateTreeNode>, [undefined]>; }, { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>; /** * Calculates the final where condition from self.baseWhere and self.where */ readonly finalWhere: unknown; } & { configureRelated(rootEntityModel: any, params: RouteConfig): void; readonly relatedFieldName: null; readonly rootEntityModel: null; readonly rootEntityModelName: null; createEntityNavigator(model: any): React.ComponentType<{}>; } & { /** * Internal. Calculate the number of all elements in list * Moved out of the ain actions so that it can be called as * yield self._count() otherwise typing of the model blows up */ _count(): Query; } & { readonly config: EntityConfig; setConfig(newConfig: EntityConfigAny): void; } & { setPageSize(pageSize: number): void; /** * Sets the query parameters for listing ServiceAccounts * @param where conditions for querying * @param orderBy sort specification for ordering result */ setQueryParams(where: unknown, orderBy: unknown[] | null): void; setBaseQueryCondition(where: unknown): void; /** * Internal. Set count of all elements we are about to display. * @param count */ _setCount(count: number | null): void; setListQueryState(state: QueryState, error?: string | undefined): void; setPageResult(pageResult: unknown[]): void; reloadList(): void; setLoadedItem(item?: unknown): void; addSelectedItem(item: unknown): void; removeSelectedItem(item: unknown): void; clearSlectedItems(): void; isSelectedItem(item: unknown): any; setCreatedItem(item?: unknown): void; setUpdatedItem(item?: unknown): void; setEditId(id?: string | number | null): void; setSelectedId(id?: string | number | null): void; /** * List elements on the given page * @param page page to display */ list: (page: number) => Promise>; setLoadQueryState(state: QueryState, error?: string | null): void; load(id: string): Query; setDefaultCreateFieldValues(values: { [key: string]: any; }): void; setDefaultUpdateFieldValues(values: { [key: string]: any; }): void; setUpdateMutationState(state: QueryState, error?: string | null): void; update(params: unknown): Query; setCreateMutationState(state: QueryState, error?: string | null): void; create(params: unknown): Query; setAssociateMutationState(state: QueryState, error?: string | null): void; associate(relation: any, associateIds: string[] | number[]): any; setCanUnassociateAny(flag: boolean): void; setUnassociateMutationState(state: QueryState, error?: string | null): void; unassociate(relation: any, associateIds: string[] | number[]): any; setDeleteMutationState(state: QueryState, error?: string | null): void; delete(items: unknown[]): Query; setJoinFields(joinFields: { [key: string]: any; }): void; } & import("mobx-state-tree").IStateTreeNode, [undefined]>; pageSize: IOptionalIType, [undefined]>; count: import("mobx-state-tree").IMaybeNull>; joinFields: import("mobx-state-tree").IMaybeNull>; baseWhere: import("mobx-state-tree").IMaybeNull>; where: import("mobx-state-tree").IMaybeNull>; orderBy: IOptionalIType, [undefined]>; listQueryState: import("mobx-state-tree").IMaybeNull>; listQueryError: import("mobx-state-tree").IMaybe>; updateMutationState: import("mobx-state-tree").IMaybeNull>; updateMutationError: import("mobx-state-tree").IMaybeNull>; createMutationState: import("mobx-state-tree").IMaybeNull>; createMutationError: import("mobx-state-tree").IMaybeNull>; deleteMutationState: import("mobx-state-tree").IMaybeNull>; deleteMutationError: import("mobx-state-tree").IMaybeNull>; associateMutationState: import("mobx-state-tree").IMaybeNull>; associateMutationError: import("mobx-state-tree").IMaybeNull>; canUnassociateAny: IOptionalIType, [undefined]>; unassociateMutationState: import("mobx-state-tree").IMaybeNull>; unassociateMutationError: import("mobx-state-tree").IMaybeNull>; pageResult: IOptionalIType>>, [undefined]>; editId: import("mobx-state-tree").IMaybeNull>; selectedId: import("mobx-state-tree").IMaybeNull>; defaultCreateFieldValues: import("mobx-state-tree").IMaybeNull>; defaultUpdateFieldValues: import("mobx-state-tree").IMaybeNull>; loadQueryState: import("mobx-state-tree").IMaybeNull>; loadQueryError: import("mobx-state-tree").IMaybeNull>; loadedItem: import("mobx-state-tree").IMaybeNull>>; selectedItems: IOptionalIType>>, [undefined]>; createdItem: import("mobx-state-tree").IMaybeNull>>; updatedItem: import("mobx-state-tree").IMaybeNull>>; relations: IOptionalIType, [undefined]>; }, { getParentField(field: string): any; } & { afterCreate: () => void; reset: () => void; } & { readonly numberOfPages: number; readonly gqlStore: { __queryCache: import("mobx-state-tree").IMSTMap> & import("mobx-state-tree").IStateTreeNode>, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; } & import("mobx-state-tree").IStateTreeNode>, [undefined]>; }, { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>; /** * Calculates the final where condition from self.baseWhere and self.where */ readonly finalWhere: unknown; } & { configureRelated(rootEntityModel: any, params: RouteConfig): void; readonly relatedFieldName: null; readonly rootEntityModel: null; readonly rootEntityModelName: null; createEntityNavigator(model: any): React.ComponentType<{}>; } & { /** * Internal. Calculate the number of all elements in list * Moved out of the ain actions so that it can be called as * yield self._count() otherwise typing of the model blows up */ _count(): Query; } & { readonly config: EntityConfig; setConfig(newConfig: EntityConfigAny): void; } & { setPageSize(pageSize: number): void; /** * Sets the query parameters for listing ServiceAccounts * @param where conditions for querying * @param orderBy sort specification for ordering result */ setQueryParams(where: unknown, orderBy: unknown[] | null): void; setBaseQueryCondition(where: unknown): void; /** * Internal. Set count of all elements we are about to display. * @param count */ _setCount(count: number | null): void; setListQueryState(state: QueryState, error?: string | undefined): void; setPageResult(pageResult: unknown[]): void; reloadList(): void; setLoadedItem(item?: unknown): void; addSelectedItem(item: unknown): void; removeSelectedItem(item: unknown): void; clearSlectedItems(): void; isSelectedItem(item: unknown): any; setCreatedItem(item?: unknown): void; setUpdatedItem(item?: unknown): void; setEditId(id?: string | number | null): void; setSelectedId(id?: string | number | null): void; /** * List elements on the given page * @param page page to display */ list: (page: number) => Promise>; setLoadQueryState(state: QueryState, error?: string | null): void; load(id: string): Query; setDefaultCreateFieldValues(values: { [key: string]: any; }): void; setDefaultUpdateFieldValues(values: { [key: string]: any; }): void; setUpdateMutationState(state: QueryState, error?: string | null): void; update(params: unknown): Query; setCreateMutationState(state: QueryState, error?: string | null): void; create(params: unknown): Query; setAssociateMutationState(state: QueryState, error?: string | null): void; associate(relation: any, associateIds: string[] | number[]): any; setCanUnassociateAny(flag: boolean): void; setUnassociateMutationState(state: QueryState, error?: string | null): void; unassociate(relation: any, associateIds: string[] | number[]): any; setDeleteMutationState(state: QueryState, error?: string | null): void; delete(items: unknown[]): Query; setJoinFields(joinFields: { [key: string]: any; }): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) => boolean) | undefined; readonly prepareNew: ((gqlStore: { __queryCache: import("mobx-state-tree").IMSTMap> & import("mobx-state-tree").IStateTreeNode>, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; } & import("mobx-state-tree").IStateTreeNode>, [undefined]>; }, { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>, rootEntityModel: { currentPage: number; pageSize: number; count: number | null; joinFields: ({ [key: string]: any; } & import("mobx-state-tree").IStateTreeNode>>) | null; baseWhere: unknown; where: unknown; orderBy: unknown[] & import("mobx-state-tree").IStateTreeNode, [undefined]>>; listQueryState: QueryState | null; listQueryError: string | undefined; updateMutationState: QueryState | null; updateMutationError: string | null; createMutationState: QueryState | null; createMutationError: string | null; deleteMutationState: QueryState | null; deleteMutationError: string | null; associateMutationState: QueryState | null; associateMutationError: string | null; canUnassociateAny: boolean; unassociateMutationState: QueryState | null; unassociateMutationError: string | null; pageResult: import("mobx-state-tree").IMSTArray>> & import("mobx-state-tree").IStateTreeNode>>, [undefined]>>; editId: string | number | null; selectedId: string | number | null; defaultCreateFieldValues: ({ [key: string]: any; } & import("mobx-state-tree").IStateTreeNode>>) | null; defaultUpdateFieldValues: ({ [key: string]: any; } & import("mobx-state-tree").IStateTreeNode>>) | null; loadQueryState: QueryState | null; loadQueryError: string | null; loadedItem: any; selectedItems: import("mobx-state-tree").IMSTArray>> & import("mobx-state-tree").IStateTreeNode>>, [undefined]>>; createdItem: any; updatedItem: any; relations: {} & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree").IStateTreeNode, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { getParentField(field: string): any; } & { afterCreate: () => void; reset: () => void; } & { readonly numberOfPages: number; readonly gqlStore: { __queryCache: import("mobx-state-tree").IMSTMap> & import("mobx-state-tree").IStateTreeNode>, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; } & import("mobx-state-tree").IStateTreeNode>, [undefined]>; }, { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>; /** * Calculates the final where condition from self.baseWhere and self.where */ readonly finalWhere: unknown; } & { configureRelated(rootEntityModel: any, params: RouteConfig): void; readonly relatedFieldName: null; readonly rootEntityModel: null; readonly rootEntityModelName: null; createEntityNavigator(model: any): React.ComponentType<{}>; } & { /** * Internal. Calculate the number of all elements in list * Moved out of the ain actions so that it can be called as * yield self._count() otherwise typing of the model blows up */ _count(): Query; } & { readonly config: EntityConfig; setConfig(newConfig: EntityConfigAny): void; } & { setPageSize(pageSize: number): void; /** * Sets the query parameters for listing ServiceAccounts * @param where conditions for querying * @param orderBy sort specification for ordering result */ setQueryParams(where: unknown, orderBy: unknown[] | null): void; setBaseQueryCondition(where: unknown): void; /** * Internal. Set count of all elements we are about to display. * @param count */ _setCount(count: number | null): void; setListQueryState(state: QueryState, error?: string | undefined): void; setPageResult(pageResult: unknown[]): void; reloadList(): void; setLoadedItem(item?: unknown): void; addSelectedItem(item: unknown): void; removeSelectedItem(item: unknown): void; clearSlectedItems(): void; isSelectedItem(item: unknown): any; setCreatedItem(item?: unknown): void; setUpdatedItem(item?: unknown): void; setEditId(id?: string | number | null): void; setSelectedId(id?: string | number | null): void; /** * List elements on the given page * @param page page to display */ list: (page: number) => Promise>; setLoadQueryState(state: QueryState, error?: string | null): void; load(id: string): Query; setDefaultCreateFieldValues(values: { [key: string]: any; }): void; setDefaultUpdateFieldValues(values: { [key: string]: any; }): void; setUpdateMutationState(state: QueryState, error?: string | null): void; update(params: unknown): Query; setCreateMutationState(state: QueryState, error?: string | null): void; create(params: unknown): Query; setAssociateMutationState(state: QueryState, error?: string | null): void; associate(relation: any, associateIds: string[] | number[]): any; setCanUnassociateAny(flag: boolean): void; setUnassociateMutationState(state: QueryState, error?: string | null): void; unassociate(relation: any, associateIds: string[] | number[]): any; setDeleteMutationState(state: QueryState, error?: string | null): void; delete(items: unknown[]): Query; setJoinFields(joinFields: { [key: string]: any; }): void; } & import("mobx-state-tree").IStateTreeNode, [undefined]>; pageSize: IOptionalIType, [undefined]>; count: import("mobx-state-tree").IMaybeNull>; joinFields: import("mobx-state-tree").IMaybeNull>; baseWhere: import("mobx-state-tree").IMaybeNull>; where: import("mobx-state-tree").IMaybeNull>; orderBy: IOptionalIType, [undefined]>; listQueryState: import("mobx-state-tree").IMaybeNull>; listQueryError: import("mobx-state-tree").IMaybe>; updateMutationState: import("mobx-state-tree").IMaybeNull>; updateMutationError: import("mobx-state-tree").IMaybeNull>; createMutationState: import("mobx-state-tree").IMaybeNull>; createMutationError: import("mobx-state-tree").IMaybeNull>; deleteMutationState: import("mobx-state-tree").IMaybeNull>; deleteMutationError: import("mobx-state-tree").IMaybeNull>; associateMutationState: import("mobx-state-tree").IMaybeNull>; associateMutationError: import("mobx-state-tree").IMaybeNull>; canUnassociateAny: IOptionalIType, [undefined]>; unassociateMutationState: import("mobx-state-tree").IMaybeNull>; unassociateMutationError: import("mobx-state-tree").IMaybeNull>; pageResult: IOptionalIType>>, [undefined]>; editId: import("mobx-state-tree").IMaybeNull>; selectedId: import("mobx-state-tree").IMaybeNull>; defaultCreateFieldValues: import("mobx-state-tree").IMaybeNull>; defaultUpdateFieldValues: import("mobx-state-tree").IMaybeNull>; loadQueryState: import("mobx-state-tree").IMaybeNull>; loadQueryError: import("mobx-state-tree").IMaybeNull>; loadedItem: import("mobx-state-tree").IMaybeNull>>; selectedItems: IOptionalIType>>, [undefined]>; createdItem: import("mobx-state-tree").IMaybeNull>>; updatedItem: import("mobx-state-tree").IMaybeNull>>; relations: IOptionalIType, [undefined]>; }, { getParentField(field: string): any; } & { afterCreate: () => void; reset: () => void; } & { readonly numberOfPages: number; readonly gqlStore: { __queryCache: import("mobx-state-tree").IMSTMap> & import("mobx-state-tree").IStateTreeNode>, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; } & import("mobx-state-tree").IStateTreeNode>, [undefined]>; }, { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>; /** * Calculates the final where condition from self.baseWhere and self.where */ readonly finalWhere: unknown; } & { configureRelated(rootEntityModel: any, params: RouteConfig): void; readonly relatedFieldName: null; readonly rootEntityModel: null; readonly rootEntityModelName: null; createEntityNavigator(model: any): React.ComponentType<{}>; } & { /** * Internal. Calculate the number of all elements in list * Moved out of the ain actions so that it can be called as * yield self._count() otherwise typing of the model blows up */ _count(): Query; } & { readonly config: EntityConfig; setConfig(newConfig: EntityConfigAny): void; } & { setPageSize(pageSize: number): void; /** * Sets the query parameters for listing ServiceAccounts * @param where conditions for querying * @param orderBy sort specification for ordering result */ setQueryParams(where: unknown, orderBy: unknown[] | null): void; setBaseQueryCondition(where: unknown): void; /** * Internal. Set count of all elements we are about to display. * @param count */ _setCount(count: number | null): void; setListQueryState(state: QueryState, error?: string | undefined): void; setPageResult(pageResult: unknown[]): void; reloadList(): void; setLoadedItem(item?: unknown): void; addSelectedItem(item: unknown): void; removeSelectedItem(item: unknown): void; clearSlectedItems(): void; isSelectedItem(item: unknown): any; setCreatedItem(item?: unknown): void; setUpdatedItem(item?: unknown): void; setEditId(id?: string | number | null): void; setSelectedId(id?: string | number | null): void; /** * List elements on the given page * @param page page to display */ list: (page: number) => Promise>; setLoadQueryState(state: QueryState, error?: string | null): void; load(id: string): Query; setDefaultCreateFieldValues(values: { [key: string]: any; }): void; setDefaultUpdateFieldValues(values: { [key: string]: any; }): void; setUpdateMutationState(state: QueryState, error?: string | null): void; update(params: unknown): Query; setCreateMutationState(state: QueryState, error?: string | null): void; create(params: unknown): Query; setAssociateMutationState(state: QueryState, error?: string | null): void; associate(relation: any, associateIds: string[] | number[]): any; setCanUnassociateAny(flag: boolean): void; setUnassociateMutationState(state: QueryState, error?: string | null): void; unassociate(relation: any, associateIds: string[] | number[]): any; setDeleteMutationState(state: QueryState, error?: string | null): void; delete(items: unknown[]): Query; setJoinFields(joinFields: { [key: string]: any; }): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>, model: { currentPage: number; pageSize: number; count: number | null; joinFields: ({ [key: string]: any; } & import("mobx-state-tree").IStateTreeNode>>) | null; baseWhere: unknown; where: unknown; orderBy: unknown[] & import("mobx-state-tree").IStateTreeNode, [undefined]>>; listQueryState: QueryState | null; listQueryError: string | undefined; updateMutationState: QueryState | null; updateMutationError: string | null; createMutationState: QueryState | null; createMutationError: string | null; deleteMutationState: QueryState | null; deleteMutationError: string | null; associateMutationState: QueryState | null; associateMutationError: string | null; canUnassociateAny: boolean; unassociateMutationState: QueryState | null; unassociateMutationError: string | null; pageResult: import("mobx-state-tree").IMSTArray>> & import("mobx-state-tree").IStateTreeNode>>, [undefined]>>; editId: string | number | null; selectedId: string | number | null; defaultCreateFieldValues: ({ [key: string]: any; } & import("mobx-state-tree").IStateTreeNode>>) | null; defaultUpdateFieldValues: ({ [key: string]: any; } & import("mobx-state-tree").IStateTreeNode>>) | null; loadQueryState: QueryState | null; loadQueryError: string | null; loadedItem: any; selectedItems: import("mobx-state-tree").IMSTArray>> & import("mobx-state-tree").IStateTreeNode>>, [undefined]>>; createdItem: any; updatedItem: any; relations: {} & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree").IStateTreeNode, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { getParentField(field: string): any; } & { afterCreate: () => void; reset: () => void; } & { readonly numberOfPages: number; readonly gqlStore: { __queryCache: import("mobx-state-tree").IMSTMap> & import("mobx-state-tree").IStateTreeNode>, [undefined]>>; } & import("mobx-state-tree/dist/internal").NonEmptyObject & { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; } & import("mobx-state-tree").IStateTreeNode>, [undefined]>; }, { ssr: boolean; __promises: Map>; __afterInit: boolean; gqlHttpClient: import("mst-gql/dist/MSTGQLStore").RequestHandler; gqlWsClient: SubscriptionClient; } & { merge: (data: unknown) => any; deflate: (data: unknown) => any; mutate: (mutation: string | import("graphql").DocumentNode, variables?: any, optimisticUpdate?: (() => void) | undefined) => Query; query: (query: string | import("graphql").DocumentNode, variables?: any, options?: import("mst-gql").QueryOptions | undefined) => Query; subscribe: (query: string | import("graphql").DocumentNode, variables?: any, onData?: ((item: T_2) => void) | undefined, onError?: ((error: Error) => void) | undefined) => () => void; rawRequest: (query: string, variables: any) => Promise; setHttpClient: (value: import("mst-gql/dist/MSTGQLStore").RequestHandler) => void; setWsClient: (value: SubscriptionClient) => void; /** * Creates an MST model for listing, filtering, editing and creating records of type `ModelType`. * * As we basically want to provide the same kind of DataTable based visualisation for handling all our records it would be tedious to * generate a model, which basically always does the same but for different mst-gql generated model types. So, instead we have * createEntityModel to generate and MST model for any entity type we have providing as a configuration selection sets * for listing and loading an entity (`listOperationSelectionSet`, `loadOperationSelectionSet`) and functions for updating and creating these * entities (`updateMutation`, `createMutation`). * * Accompanying a model created by createEntityModel() there will be generic screens as well, which handle the common * functionality of listing these entities; creation and editing requires somewhat specific forms for each entity type, so these will * not be generalized. * * @param modelConfig */ __pushPromise(promise: Promise<{}>, queryKey: string): void; __runInStoreContext(fn: () => T_3): T_3; __cacheResponse(key: string, response: any): void; __onAfterInit(): void; }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>; /** * Calculates the final where condition from self.baseWhere and self.where */ readonly finalWhere: unknown; } & { configureRelated(rootEntityModel: any, params: RouteConfig): void; readonly relatedFieldName: null; readonly rootEntityModel: null; readonly rootEntityModelName: null; createEntityNavigator(model: any): React.ComponentType<{}>; } & { /** * Internal. Calculate the number of all elements in list * Moved out of the ain actions so that it can be called as * yield self._count() otherwise typing of the model blows up */ _count(): Query; } & { readonly config: EntityConfig; setConfig(newConfig: EntityConfigAny): void; } & { setPageSize(pageSize: number): void; /** * Sets the query parameters for listing ServiceAccounts * @param where conditions for querying * @param orderBy sort specification for ordering result */ setQueryParams(where: unknown, orderBy: unknown[] | null): void; setBaseQueryCondition(where: unknown): void; /** * Internal. Set count of all elements we are about to display. * @param count */ _setCount(count: number | null): void; setListQueryState(state: QueryState, error?: string | undefined): void; setPageResult(pageResult: unknown[]): void; reloadList(): void; setLoadedItem(item?: unknown): void; addSelectedItem(item: unknown): void; removeSelectedItem(item: unknown): void; clearSlectedItems(): void; isSelectedItem(item: unknown): any; setCreatedItem(item?: unknown): void; setUpdatedItem(item?: unknown): void; setEditId(id?: string | number | null): void; setSelectedId(id?: string | number | null): void; /** * List elements on the given page * @param page page to display */ list: (page: number) => Promise>; setLoadQueryState(state: QueryState, error?: string | null): void; load(id: string): Query; setDefaultCreateFieldValues(values: { [key: string]: any; }): void; setDefaultUpdateFieldValues(values: { [key: string]: any; }): void; setUpdateMutationState(state: QueryState, error?: string | null): void; update(params: unknown): Query; setCreateMutationState(state: QueryState, error?: string | null): void; create(params: unknown): Query; setAssociateMutationState(state: QueryState, error?: string | null): void; associate(relation: any, associateIds: string[] | number[]): any; setCanUnassociateAny(flag: boolean): void; setUnassociateMutationState(state: QueryState, error?: string | null): void; unassociate(relation: any, associateIds: string[] | number[]): any; setDeleteMutationState(state: QueryState, error?: string | null): void; delete(items: unknown[]): Query; setJoinFields(joinFields: { [key: string]: any; }): void; } & import("mobx-state-tree").IStateTreeNode, [undefined]>; pageSize: IOptionalIType, [undefined]>; count: import("mobx-state-tree").IMaybeNull>; joinFields: import("mobx-state-tree").IMaybeNull>; baseWhere: import("mobx-state-tree").IMaybeNull>; where: import("mobx-state-tree").IMaybeNull>; orderBy: IOptionalIType, [undefined]>; listQueryState: import("mobx-state-tree").IMaybeNull>; listQueryError: import("mobx-state-tree").IMaybe>; updateMutationState: import("mobx-state-tree").IMaybeNull>; updateMutationError: import("mobx-state-tree").IMaybeNull