How to use the @webiny/commodo-graphql.resolveList function in @webiny/commodo-graphql

}
        },
        PbElement: {
            preview({ preview }) {
                return preview ? { __typename: "File", id: preview } : null;
            }
        },
        PbQuery: {
            getPage: resolveGet(pageFetcher),
            listPages: listPages,
            listPublishedPages,
            getPublishedPage,
            getHomePage,
            getNotFoundPage,
            getErrorPage,
            listElements: resolveList(elementFetcher),
            searchTags: async (root: any, args: Object, context: Object, info: Object) => {
                const resolver = context.plugins.byName("pb-resolver-search-tags");

                return await resolver.resolve(root, args, context, info);
            },
            oembedData: oembed
        },
        PbMutation: {
            // Creates a new page
            createPage: resolveCreate(pageFetcher),
            // Deletes the entire page
            deletePage: resolveDelete(pageFetcher),
            // Sets given page as home page.
            setHomePage,
            // Creates a revision from the given revision
            createRevisionFrom: createRevisionFrom,

where: JSON
                sort: JSON
                search: SecurityRoleSearchInput
            ): SecurityRoleListResponse
        }

        extend type SecurityMutation {
            createRole(data: SecurityRoleInput!): SecurityRoleResponse
            updateRole(id: ID!, data: SecurityRoleInput!): SecurityRoleResponse
            deleteRole(id: ID!): SecurityRoleDeleteResponse
        }
    `,
    resolvers: {
        SecurityQuery: {
            getRole: resolveGet(roleFetcher),
            listRoles: resolveList(roleFetcher)
        },
        SecurityMutation: {
            createRole: resolveCreate(roleFetcher),
            updateRole: resolveUpdate(roleFetcher),
            deleteRole: resolveDelete(roleFetcher)
        }
    }
};

): I18NLocaleResponse
            
            updateI18NLocale(
                id: ID!
                data: I18NLocaleInput!
            ): I18NLocaleResponse
        
            deleteI18NLocale(
                id: ID!
            ): I18NDeleteResponse
        }
    `,
    resolvers: {
        I18NQuery: {
            getI18NLocale: resolveGet(i18NLocaleFetcher),
            listI18NLocales: resolveList(i18NLocaleFetcher),
            searchLocaleCodes,
            getI18NInformation
        },
        I18NMutation: {
            createI18NLocale: resolveCreate(i18NLocaleFetcher),
            updateI18NLocale: resolveUpdate(i18NLocaleFetcher),
            deleteI18NLocale: resolveDelete(i18NLocaleFetcher)
        }
    }
};

deleteUser(id: ID!): SecurityUserDeleteResponse
        }
    `,
    resolvers: {
        SecurityUser: {
            __resolveReference(reference, context) {
                return userFetcher(context).findById(reference.id);
            },
            avatar({ avatar }) {
                return avatar ? { __typename: "File", id: avatar } : null;
            }
        },
        SecurityQuery: {
            getCurrentUser: resolveGetCurrentUser,
            getUser: resolveGet(userFetcher),
            listUsers: resolveList(userFetcher)
        },
        SecurityMutation: {
            loginUsingIdToken: resolveLoginUsingIdToken(userFetcher),
            updateCurrentUser: resolveUpdateCurrentSecurityUser,
            createUser: resolveCreateUser(userFetcher),
            updateUser: resolveUpdateUser(userFetcher),
            deleteUser: resolveDeleteUser(userFetcher)
        }
    }
};

updateContentModel(id: ID!, data: ContentModelInput!): ContentModelResponse

                        deleteContentModel(id: ID!): CmsDeleteResponse
                    }
                `,
                resolvers: {
                    Query: {
                        cmsRead: emptyResolver,
                        cmsManage: emptyResolver
                    },
                    Mutation: {
                        cmsManage: emptyResolver
                    },
                    CmsManageQuery: {
                        getContentModel: resolveGet(contentModelFetcher),
                        listContentModels: resolveList(contentModelFetcher)
                    },
                    CmsManageMutation: {
                        createContentModel: resolveCreate(contentModelFetcher),
                        updateContentModel: resolveUpdate(contentModelFetcher),
                        deleteContentModel: resolveDelete(contentModelFetcher)
                    }
                }
            };
        },
        security: {

id: ID! 
                data: JSON!
                reCaptchaResponseToken: String
                meta: JSON
            ): FormSubmissionResponse
            
             exportFormSubmissions(
                ids: [ID] 
                parent: ID 
                form: ID 
            ): ExportFormSubmissionsResponse
        }
    `,
    resolvers: {
        FormsQuery: {
            listFormSubmissions: resolveList(getFormSubmission),
            getFormSubmission: resolveGet(getFormSubmission)
        },
        FormsMutation: {
            createFormSubmission,
            exportFormSubmissions
        }
    }
};

): PbMenuResponse
            
            updateMenu(
                id: ID!
                data: PbMenuInput!
            ): PbMenuResponse
        
            deleteMenu(
                id: ID!
            ): PbDeleteResponse
        }
    `,
    resolvers: {
        PbQuery: {
            getMenu: resolveGet(menuFetcher),
            listMenus: resolveList(menuFetcher),
            getMenuBySlug: getMenuBySlug
        },
        PbMutation: {
            createMenu: resolveCreate(menuFetcher),
            updateMenu: resolveUpdate(menuFetcher),
            deleteMenu: resolveDelete(menuFetcher)
        }
    }
};

where: JSON
                sort: JSON
                search: SecurityGroupSearchInput
            ): SecurityGroupListResponse
        }

        extend type SecurityMutation {
            createGroup(data: SecurityGroupInput!): SecurityGroupResponse
            updateGroup(id: ID!, data: SecurityGroupInput!): SecurityGroupResponse
            deleteGroup(id: ID!): SecurityGroupDeleteResponse
        }
    `,
    resolvers: {
        SecurityQuery: {
            getGroup: resolveGet(groupFetcher),
            listGroups: resolveList(groupFetcher)
        },
        SecurityMutation: {
            createGroup: resolveCreate(groupFetcher),
            updateGroup: resolveUpdate(groupFetcher),
            deleteGroup: resolveDelete(groupFetcher)
        }
    }
};

): PbCategoryResponse
            
            updateCategory(
                id: ID!
                data: PbCategoryInput!
            ): PbCategoryResponse
        
            deleteCategory(
                id: ID!
            ): PbDeleteResponse
        }
    `,
    resolvers: {
        PbQuery: {
            getCategory: resolveGet(categoryFetcher),
            listCategories: resolveList(categoryFetcher)
        },
        PbMutation: {
            createCategory: resolveCreate(categoryFetcher),
            updateCategory: resolveUpdate(categoryFetcher),
            deleteCategory: resolveDelete(categoryFetcher)
        }
    }
};