refactored CustomStructureProperties & updated RCSB assembly symmetry

- CustomStructureProperties.attach recieves runtime and fetch context
- RCSBAsseblySymmetry uses updated data API

src/mol-model-props/common/custom-property-registry.ts

@@ -69,6 +69,13 @@ namespace CustomPropertyRegistry {
     export type StructureProvider = Provider<Structure>
 }
 
+type AjaxTask = import('../../mol-util/data-source').AjaxTask
+
+export interface CustomPropertyContext {
+    runtime: RuntimeContext
+    fetch: AjaxTask
+}
+
 export { CustomStructureProperty }
 
 namespace CustomStructureProperty {
@@ -77,7 +84,7 @@ namespace CustomStructureProperty {
         readonly descriptor: CustomPropertyDescriptor
         readonly getParams: (data: Structure) => Params
         readonly isApplicable: (data: Structure) => boolean
-        readonly attach: (data: Structure, props?: Partial<PD.Values<Params>>) => Task<void>
+        readonly attach: (ctx: CustomPropertyContext, data: Structure, props?: Partial<PD.Values<Params>>) => Promise<void>
         readonly getValue: (data: Structure) => ValueBox<Value | undefined>
         readonly setProps: (data: Structure, props: PD.Values<Params>) => void
     }
@@ -88,7 +95,7 @@ namespace CustomStructureProperty {
         readonly defaultParams: Params
         readonly getParams: (data: Structure) => Params
         readonly isApplicable: (data: Structure) => boolean
-        readonly compute: (ctx: RuntimeContext, data: Structure, props: PD.Values<Params>) => Promise<Value>
+        readonly obtain: (ctx: CustomPropertyContext, data: Structure, props: PD.Values<Params>) => Promise<Value>
         readonly type: 'root' | 'local'
     }
 
@@ -118,15 +125,15 @@ namespace CustomStructureProperty {
             descriptor: builder.descriptor,
             getParams: builder.getParams,
             isApplicable: builder.isApplicable,
-            attach: (data: Structure, props: Partial<PD.Values<Params>> = {}) => Task.create(`Attach ${builder.label}`, async ctx => {
+            attach: async (ctx: CustomPropertyContext, data: Structure, props: Partial<PD.Values<Params>> = {}) => {
                 if (builder.type === 'root') data = data.root
                 const property = get(data)
                 const p = { ...property.props, ...props }
                 if (property.data.value && PD.areEqual(builder.defaultParams, property.props, p)) return
-                const value = await builder.compute(ctx, data, p)
+                const value = await builder.obtain(ctx, data, p)
                 data.customPropertyDescriptors.add(builder.descriptor);
                 set(data, p, value);
-            }),
+            },
             getValue: (data: Structure) => get(data)?.data,
             setProps: (data: Structure, props: Partial<PD.Values<Params>> = {}) => {
                 const property = get(data)

src/mol-model-props/computed/accessible-surface-area.ts

@@ -8,8 +8,7 @@
 import { ParamDefinition as PD } from '../../mol-util/param-definition'
 import { ShrakeRupleyComputationParams, AccessibleSurfaceArea } from './accessible-surface-area/shrake-rupley';
 import { Structure, CustomPropertyDescriptor } from '../../mol-model/structure';
-import { RuntimeContext } from '../../mol-task';
-import { CustomStructureProperty } from '../common/custom-property-registry';
+import { CustomStructureProperty, CustomPropertyContext } from '../common/custom-property-registry';
 
 export const AccessibleSurfaceAreaParams = {
     ...ShrakeRupleyComputationParams
@@ -30,8 +29,8 @@ export const AccessibleSurfaceAreaProvider: CustomStructureProperty.Provider<Acc
     defaultParams: AccessibleSurfaceAreaParams,
     getParams: (data: Structure) => AccessibleSurfaceAreaParams,
     isApplicable: (data: Structure) => true,
-    compute: async (ctx: RuntimeContext, data: Structure, props: Partial<AccessibleSurfaceAreaProps>) => {
+    obtain: async (ctx: CustomPropertyContext, data: Structure, props: Partial<AccessibleSurfaceAreaProps>) => {
         const p = { ...PD.getDefaultValues(AccessibleSurfaceAreaParams), ...props }
-        return await AccessibleSurfaceArea.compute(data, p).runInContext(ctx)
+        return await AccessibleSurfaceArea.compute(data, p).runInContext(ctx.runtime)
     }
 })

src/mol-model-props/computed/interactions.ts

@@ -5,10 +5,9 @@
  */
 
 import { CustomPropertyDescriptor, Structure } from '../../mol-model/structure';
-import { RuntimeContext } from '../../mol-task';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { computeInteractions, Interactions, InteractionsParams as _InteractionsParams } from './interactions/interactions';
-import { CustomStructureProperty } from '../common/custom-property-registry';
+import { CustomStructureProperty, CustomPropertyContext } from '../common/custom-property-registry';
 
 export const InteractionsParams = {
     ..._InteractionsParams
@@ -29,7 +28,7 @@ export const InteractionsProvider: CustomStructureProperty.Provider<Interactions
     defaultParams: InteractionsParams,
     getParams: (data: Structure) => InteractionsParams,
     isApplicable: (data: Structure) => true,
-    compute: async (ctx: RuntimeContext, data: Structure, props: Partial<InteractionsProps>) => {
+    obtain: async (ctx: CustomPropertyContext, data: Structure, props: Partial<InteractionsProps>) => {
         const p = { ...PD.getDefaultValues(InteractionsParams), ...props }
         return await computeInteractions(ctx, data, p)
     }

src/mol-model-props/computed/interactions/interactions.ts

@@ -6,7 +6,6 @@
 
 import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 import { Structure, Unit } from '../../../mol-model/structure';
-import { RuntimeContext } from '../../../mol-task';
 import { Features, FeaturesBuilder } from './features';
 import { ValenceModelProvider } from '../valence-model';
 import { InteractionsIntraContacts, InteractionsInterContacts, FeatureType } from './common';
@@ -22,6 +21,7 @@ import { SetUtils } from '../../../mol-util/set';
 import { MetalCoordinationProvider, MetalProvider, MetalBindingProvider } from './metal';
 import { refineInteractions } from './refine';
 import { Result } from '../../../mol-math/geometry';
+import { CustomPropertyContext } from '../../common/custom-property-registry';
 
 export { Interactions }
 
@@ -148,9 +148,9 @@ export const InteractionsParams = {
 export type InteractionsParams = typeof InteractionsParams
 export type InteractionsProps = PD.Values<InteractionsParams>
 
-export async function computeInteractions(runtime: RuntimeContext, structure: Structure, props: Partial<InteractionsProps>): Promise<Interactions> {
+export async function computeInteractions(ctx: CustomPropertyContext, structure: Structure, props: Partial<InteractionsProps>): Promise<Interactions> {
     const p = { ...PD.getDefaultValues(InteractionsParams), ...props }
-    await ValenceModelProvider.attach(structure).runInContext(runtime)
+    await ValenceModelProvider.attach(ctx, structure)
 
     const contactProviders: ContactProvider<any>[] = []
     Object.keys(ContactProviders).forEach(k => {
@@ -167,8 +167,8 @@ export async function computeInteractions(runtime: RuntimeContext, structure: St
 
     for (let i = 0, il = structure.unitSymmetryGroups.length; i < il; ++i) {
         const group = structure.unitSymmetryGroups[i]
-        if (runtime.shouldUpdate) {
-            await runtime.update({ message: 'computing interactions', current: i, max: il })
+        if (ctx.runtime.shouldUpdate) {
+            await ctx.runtime.update({ message: 'computing interactions', current: i, max: il })
         }
         const features = findUnitFeatures(structure, group.units[0], featureProviders)
         const intraUnitContacts = findIntraUnitContacts(structure, group.units[0], features, contactTesters, p.contacts)

src/mol-model-props/computed/secondary-structure.ts

@@ -5,12 +5,11 @@
  */
 
 import { CustomPropertyDescriptor, Structure } from '../../mol-model/structure';
-import { RuntimeContext } from '../../mol-task';
 import { DSSPComputationParams, DSSPComputationProps, computeUnitDSSP } from './secondary-structure/dssp';
 import { SecondaryStructure } from '../../mol-model/structure/model/properties/seconday-structure';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { Unit } from '../../mol-model/structure/structure';
-import { CustomStructureProperty } from '../common/custom-property-registry';
+import { CustomStructureProperty, CustomPropertyContext } from '../common/custom-property-registry';
 
 function getSecondaryStructureParams(data?: Structure) {
     let defaultType = 'mmcif' as 'mmcif' | 'dssp'
@@ -56,7 +55,7 @@ export const SecondaryStructureProvider: CustomStructureProperty.Provider<Second
     defaultParams: SecondaryStructureParams,
     getParams: getSecondaryStructureParams,
     isApplicable: (data: Structure) => true,
-    compute: async (ctx: RuntimeContext, data: Structure, props: Partial<SecondaryStructureProps>) => {
+    obtain: async (ctx: CustomPropertyContext, data: Structure, props: Partial<SecondaryStructureProps>) => {
         const p = { ...PD.getDefaultValues(SecondaryStructureParams), ...props }
         switch (p.type.name) {
             case 'dssp': return await computeDssp(data, p.type.params)

src/mol-model-props/computed/valence-model.ts

@@ -5,10 +5,9 @@
  */
 
 import { CustomPropertyDescriptor, Structure } from '../../mol-model/structure';
-import { RuntimeContext } from '../../mol-task';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { calcValenceModel, ValenceModel, ValenceModelParams as _ValenceModelParams } from './chemistry/valence-model';
-import { CustomStructureProperty } from '../common/custom-property-registry';
+import { CustomStructureProperty, CustomPropertyContext } from '../common/custom-property-registry';
 
 export const ValenceModelParams = {
     ..._ValenceModelParams
@@ -29,8 +28,8 @@ export const ValenceModelProvider: CustomStructureProperty.Provider<ValenceModel
     defaultParams: ValenceModelParams,
     getParams: (data: Structure) => ValenceModelParams,
     isApplicable: (data: Structure) => true,
-    compute: async (ctx: RuntimeContext, data: Structure, props: Partial<ValenceModelProps>) => {
+    obtain: async (ctx: CustomPropertyContext, data: Structure, props: Partial<ValenceModelProps>) => {
         const p = { ...PD.getDefaultValues(ValenceModelParams), ...props }
-        return await calcValenceModel(ctx, data, p)
+        return await calcValenceModel(ctx.runtime, data, p)
     }
 })

src/mol-model-props/rcsb/assembly-symmetry.ts

@@ -1,297 +1,78 @@
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import { AssemblySymmetry as AssemblySymmetryGraphQL } from './graphql/types';
+import { AssemblySymmetryQuery, AssemblySymmetryQueryVariables } from './graphql/types';
 import query from './graphql/symmetry.gql';
 
-import { Model, CustomPropertyDescriptor } from '../../mol-model/structure';
-import { CifWriter } from '../../mol-io/writer/cif';
-import { Database as _Database, Column, Table } from '../../mol-data/db'
-import { Category } from '../../mol-io/writer/cif/encoder';
-import { Tensor } from '../../mol-math/linear-algebra';
-import { CifExportContext } from '../../mol-model/structure/export/mmcif';
-import { toTable } from '../../mol-io/reader/cif/schema';
-import { CifCategory } from '../../mol-io/reader/cif';
-import { PropertyWrapper } from '../../mol-model-props/common/wrapper';
-import { Task, RuntimeContext } from '../../mol-task';
+import { ParamDefinition as PD } from '../../mol-util/param-definition'
+import { CustomPropertyDescriptor, Structure } from '../../mol-model/structure';
+import { Database as _Database } from '../../mol-data/db'
 import { GraphQLClient } from '../../mol-util/graphql-client';
+import { CustomStructureProperty, CustomPropertyContext } from '../common/custom-property-registry';
+import { Loci, isDataLoci, DataLoci, createDataLoci } from '../../mol-model/loci';
+import { NonNullableArray } from '../../mol-util/type-helpers';
+import { OrderedSet } from '../../mol-data/int';
 
-const { str, int, float, Aliased, Vector, List } = Column.Schema;
-
-function getInstance(name: keyof AssemblySymmetry.Schema): (ctx: CifExportContext) => CifWriter.Category.Instance<any, any> {
-    return function(ctx: CifExportContext) {
-        const assemblySymmetry = AssemblySymmetry.get(ctx.structures[0].model);
-        return assemblySymmetry ? Category.ofTable(assemblySymmetry.db[name]) : CifWriter.Category.Empty;
-    }
-}
-
-function getCategory(name: keyof AssemblySymmetry.Schema) {
-    return { name, instance: getInstance(name) }
-}
-
-function createDatabaseFromJson(assemblies: ReadonlyArray<AssemblySymmetryGraphQL.Assemblies>): AssemblySymmetry.Database {
-    const Schema = AssemblySymmetry.Schema
-
-    const featureRows: Table.Row<typeof Schema.rcsb_assembly_symmetry>[] = []
-    const clusterRows: Table.Row<typeof Schema.rcsb_assembly_symmetry_cluster>[] = []
-    const clusterMemberRows: Table.Row<typeof Schema.rcsb_assembly_symmetry_cluster_member>[] = []
-    const axisRows: Table.Row<typeof Schema.rcsb_assembly_symmetry_axis>[] = []
-
-    let id = 1 // start feature ids at 1
-    let clusterCount = 0
-    for (let i = 0, il = assemblies.length; i < il; ++i) {
-        const { pdbx_struct_assembly, rcsb_struct_symmetry } = assemblies[i]
-        if (!pdbx_struct_assembly || !rcsb_struct_symmetry) continue
-        const assembly_id = pdbx_struct_assembly.id
-        for (let j = 0, jl = rcsb_struct_symmetry.length; j < jl; ++j) {
-            const rss = rcsb_struct_symmetry[j]! // TODO upstream, array members should not be nullable
-            featureRows.push({
-                id,
-                assembly_id,
-                type: rss.type as SymmetryType,
-                stoichiometry: rss.stoichiometry as string[],  // TODO upstream, array members should not be nullable
-                kind: rss.kind as SymmetryKind,
-                symbol: rss.symbol,
-                oligomeric_state: rss.oligomeric_state
-            })
-
-            const clusters = rss.clusters
-            if (clusters) {
-                for (let k = 0, kl = clusters.length; k < kl; ++k) {
-                    const c = clusters[k]! // TODO upstream, array members should not be nullable
-                    const cluster_id = clusterCount + k
-                    clusterRows.push({
-                        id: cluster_id,
-                        symmetry_id: id,
-                        avg_rmsd: c.avg_rmsd || 0, // TODO upstream, should not be nullable, or???
-                    })
-                    for (let l = 0, ll = c.members.length; l < ll; ++l) {
-                        const m = c.members[l]! // TODO upstream, array members should not be nullable
-                        clusterMemberRows.push({
-                            cluster_id: cluster_id,
-                            asym_id: m.asym_id,
-                            pdbx_struct_oper_list_ids: (m.pdbx_struct_oper_list_ids || []) as string[]
-                        })
-                    }
-                }
-                clusterCount += clusters.length
-            }
-
-            const axes = rss.rotation_axes
-            if (axes) {
-                for (let k = 0, kl = axes.length; k < kl; ++k) {
-                    const a = axes[k]!
-                    axisRows.push({
-                        symmetry_id: id,
-                        order: a.order!,  // TODO upstream, should not be nullable, or???
-                        start: a.start as Tensor.Data, // TODO upstream, array members should not be nullable
-                        end: a.end as Tensor.Data // TODO upstream, array members should not be nullable
-                    })
-                }
-            }
-
-            id += 1
-        }
-    }
-
-    return _Database.ofTables('assembly_symmetry', Schema, {
-        rcsb_assembly_symmetry: Table.ofRows(Schema.rcsb_assembly_symmetry, featureRows),
-        rcsb_assembly_symmetry_cluster: Table.ofRows(Schema.rcsb_assembly_symmetry_cluster, clusterRows),
-        rcsb_assembly_symmetry_cluster_member: Table.ofRows(Schema.rcsb_assembly_symmetry_cluster_member, clusterMemberRows),
-        rcsb_assembly_symmetry_axis: Table.ofRows(Schema.rcsb_assembly_symmetry_axis, axisRows)
-    })
-}
-
-function createDatabaseFromCif(model: Model): AssemblySymmetry.Database {
-    const Schema = AssemblySymmetry.Schema
-
-    const rcsb_assembly_symmetry = toTable(Schema.rcsb_assembly_symmetry, model.sourceData.frame.categories.rcsb_assembly_symmetry_feature)
-
-    let rcsb_assembly_symmetry_cluster
-    if (model.sourceData.frame.categoryNames.includes('rcsb_assembly_symmetry_cluster')) {
-        rcsb_assembly_symmetry_cluster = toTable(Schema.rcsb_assembly_symmetry_cluster, model.sourceData.frame.categories.rcsb_assembly_symmetry_cluster)
-    } else {
-        rcsb_assembly_symmetry_cluster = toTable(Schema.rcsb_assembly_symmetry_cluster, CifCategory.empty as any)
-    }
-
-    let rcsb_assembly_symmetry_cluster_member
-    if (model.sourceData.frame.categoryNames.includes('rcsb_assembly_symmetry_cluster_member')) {
-        rcsb_assembly_symmetry_cluster_member = toTable(Schema.rcsb_assembly_symmetry_cluster_member, model.sourceData.frame.categories.rcsb_assembly_symmetry_cluster_member)
-    } else {
-        rcsb_assembly_symmetry_cluster_member = toTable(Schema.rcsb_assembly_symmetry_cluster_member, CifCategory.empty as any)
-    }
-
-    let rcsb_assembly_symmetry_axis
-    if (model.sourceData.frame.categoryNames.includes('rcsb_assembly_symmetry_axis')) {
-        rcsb_assembly_symmetry_axis = toTable(Schema.rcsb_assembly_symmetry_axis, model.sourceData.frame.categories.rcsb_assembly_symmetry_axis)
-    } else {
-        rcsb_assembly_symmetry_axis = toTable(Schema.rcsb_assembly_symmetry_axis, CifCategory.empty as any)
-    }
-
-    return _Database.ofTables('rcsb_assembly_symmetry', Schema, {
-        rcsb_assembly_symmetry,
-        rcsb_assembly_symmetry_cluster,
-        rcsb_assembly_symmetry_cluster_member,
-        rcsb_assembly_symmetry_axis
-    })
-}
+export namespace AssemblySymmetry {
+    export const DefaultServerUrl = 'http://data-staging.rcsb.org/graphql'
 
-const _Descriptor: CustomPropertyDescriptor = {
-    isStatic: true,
-    name: 'rcsb_assembly_symmetry',
-    cifExport: {
-        prefix: 'rcsb',
-        categories: [
-            PropertyWrapper.defaultInfoCategory<CifExportContext>('rcsb_assembly_symmetry_info', ctx => PropertyWrapper.createInfo()),
-            getCategory('rcsb_assembly_symmetry'),
-            getCategory('rcsb_assembly_symmetry_cluster'),
-            getCategory('rcsb_assembly_symmetry_cluster_member'),
-            getCategory('rcsb_assembly_symmetry_axis')
-        ]
+    const AxesLociTag = 'rcsb_assembly_symmetry_axes'
+    export function createAxesLoci(assemblySymmetry: AssemblySymmetryValue, indices: OrderedSet): DataLoci<AssemblySymmetryValue> {
+        return createDataLoci(assemblySymmetry, AxesLociTag, indices)
     }
-}
-
-export interface AssemblySymmetry {
-    '@type': 'rcsb_assembly_symmetry',
-    db: AssemblySymmetry.Database
-    getSymmetries(assemblyIds: string[]): Table<AssemblySymmetry.Schema['rcsb_assembly_symmetry']>
-    getClusters(symmetryId: number): Table<AssemblySymmetry.Schema['rcsb_assembly_symmetry_cluster']>
-    getClusterMembers(clusterId: number): Table<AssemblySymmetry.Schema['rcsb_assembly_symmetry_cluster_member']>
-    getAxes(symmetryId: number): Table<AssemblySymmetry.Schema['rcsb_assembly_symmetry_axis']>
-}
-
-export function AssemblySymmetry(db: AssemblySymmetry.Database): AssemblySymmetry {
-    const f = db.rcsb_assembly_symmetry
-    const c = db.rcsb_assembly_symmetry_cluster
-    const cm = db.rcsb_assembly_symmetry_cluster_member
-    const a = db.rcsb_assembly_symmetry_axis
-
-    return {
-        '@type': 'rcsb_assembly_symmetry',
-        db,
-        getSymmetries: (assemblyIds: string[]) => Table.pick(f, f._schema, i => assemblyIds.includes(f.assembly_id.value(i))),
-        getClusters: (symmetryId: number) => Table.pick(c, c._schema, i => c.symmetry_id.value(i) === symmetryId),
-        getClusterMembers: (clusterId: number) => Table.pick(cm, cm._schema, i => cm.cluster_id.value(i) === clusterId),
-        getAxes: (symmetryId: number) => Table.pick(a, a._schema, i => a.symmetry_id.value(i) === symmetryId),
+    export function isAxesLoci(x?: Loci): x is DataLoci<AssemblySymmetryValue> {
+        return isDataLoci(x) && x.tag === AxesLociTag
     }
-}
-
-type SymmetryKind = 'GLOBAL' | 'LOCAL' | 'PSEUDO'
-type SymmetryType = 'ASYMMETRIC' | 'CYCLIC' | 'DIHEDRAL' | 'HELICAL' | 'ICOSAHEDRAL' | 'OCTAHEDRAL' | 'TETRAHEDRAL'
 
-export namespace AssemblySymmetry {
-    export function is(x: any): x is AssemblySymmetry {
-        return x['@type'] === 'rcsb_assembly_symmetry'
+    export function isApplicable(structure?: Structure): boolean {
+        return (
+            !!structure &&
+            structure.models.length === 1 &&
+            structure.models[0].sourceData.kind === 'mmCIF' &&
+            (structure.models[0].sourceData.data.database_2.database_id.isDefined ||
+                structure.models[0].entryId.length === 4)
+        )
     }
-    export const GraphQLEndpointURL = '//rest-staging.rcsb.org/graphql'
 
-    export const Schema = {
-        rcsb_assembly_symmetry_info: {
-            updated_datetime_utc: Column.Schema.str
-        },
-        rcsb_assembly_symmetry: {
-            /** Uniquely identifies a record in `rcsb_assembly_symmetry` */
-            id: int,
-            /**
-             * A pointer to `pdbx_struct_assembly.id`.
-             * The value 'deposited' refers to the coordinates as given in the file.
-             * */
-            assembly_id: str,
-            /** Type of protein symmetry */
-            kind: Aliased<SymmetryKind>(str),
-            /** Quantitative description of every individual subunit in a given protein */
-            stoichiometry: List(',', x => x),
-            /**
-             * Symmetry symbol refers to point group or helical symmetry of identical subunits.
-             * Contains point group symbol (e.g., C2, C5, D2, T, O, I) or H for helical symmetry.
-             */
-            symbol: str,
-            /** Point group or helical symmetry */
-            type: Aliased<SymmetryType>(str),
-            /**
-             * Oligomeric state refers to a composition of subunits in quaternary structure.
-             * Quaternary structure may be composed either exclusively of several copies of identical
-             * subunits, in which case they are termed homo-oligomers, or alternatively by at least
-             * one copy of different subunits (hetero-oligomers). Quaternary structure composed of
-             * a single subunit is demoted as 'Monomer'.
-             */
-            oligomeric_state: str,
-        },
-        rcsb_assembly_symmetry_cluster: {
-            /** Uniquely identifies a record in `rcsb_assembly_symmetry_cluster` */
-            id: int,
-            /** A pointer to `rcsb_assembly_symmetry.id` */
-            symmetry_id: int,
-            /** Average RMSD between members of a given cluster */
-            avg_rmsd: float
-        },
-        rcsb_assembly_symmetry_cluster_member: {
-            /** A pointer to `rcsb_assembly_symmetry_cluster.id` */
-            cluster_id: int,
-            /** The `label_asym_id` value of the member */
-            asym_id: str,
-            /** List of `pdbx_struct_oper_list_id` values of the member */
-            pdbx_struct_oper_list_ids: List(',', x => x)
-        },
-        rcsb_assembly_symmetry_axis: {
-            /** A pointer to `rcsb_assembly_symmetry.id` */
-            symmetry_id: int,
-            /**
-             * The number of times (order of rotation) that a subunit can be repeated by a rotation
-             * operation, being transformed into a new state indistinguishable from its starting state.
-             */
-            order: int,
-            /** The x,y,z coordinate of the start point of a symmetry axis */
-            start: Vector(3),
-            /** The x,y,z coordinate of the end point of a symmetry axis */
-            end: Vector(3)
+    export async function compute(ctx: CustomPropertyContext, structure: Structure, props: AssemblySymmetryProps): Promise<AssemblySymmetryValue> {
+        const client = new GraphQLClient(props.serverUrl, ctx.fetch)
+        const variables: AssemblySymmetryQueryVariables = {
+            assembly_id: structure.units[0].conformation.operator.assembly.id,
+            entry_id: structure.units[0].model.entryId
         }
-    }
-    export type Schema = typeof Schema
-    export interface Database extends _Database<Schema> {}
-
-    export const Descriptor = _Descriptor;
+        const result = await client.request<AssemblySymmetryQuery>(ctx.runtime, query, variables)
 
-    export async function attachFromCifOrAPI(model: Model, client: GraphQLClient, ctx?: RuntimeContext) {
-        if (model.customProperties.has(Descriptor)) return true;
-
-        let db: Database
-        let info = PropertyWrapper.tryGetInfoFromCif('rcsb_assembly_symmetry_info', model);
-        if (info) {
-            db = createDatabaseFromCif(model)
-        } else {
-            let result: AssemblySymmetryGraphQL.Query
-            console.log('model.entryId.toLowerCase()', model.entryId.toLowerCase())
-            const variables: AssemblySymmetryGraphQL.Variables = { pdbId: model.entryId.toLowerCase() };
-            try {
-                console.log('foo', client)
-                result = await client.request<AssemblySymmetryGraphQL.Query>(ctx || RuntimeContext.Synchronous, query, variables);
-            } catch (e) {
-                console.error(e)
-                return false;
-            }
-            if (!result || !result.entry || !result.entry.assemblies) return false;
-
-            db = createDatabaseFromJson(result.entry.assemblies as ReadonlyArray<AssemblySymmetryGraphQL.Assemblies>)
+        if (!result.assembly?.rcsb_struct_symmetry) {
+            throw new Error('missing fields')
         }
-
-        model.customProperties.add(Descriptor);
-        model._staticPropertyData.__RCSBAssemblySymmetry__ = AssemblySymmetry(db);
-        return true;
-    }
-
-    export function createAttachTask(fetch: import('../../mol-util/data-source').AjaxTask) {
-        return (model: Model) => Task.create('RCSB Assembly Symmetry', async ctx => {
-            if (get(model)) return true;
-
-            return await attachFromCifOrAPI(model, new GraphQLClient(AssemblySymmetry.GraphQLEndpointURL, fetch), ctx)
-        });
+        return result.assembly.rcsb_struct_symmetry as AssemblySymmetryValue
     }
+}
 
-    export function get(model: Model): AssemblySymmetry | undefined {
-        return model._staticPropertyData.__RCSBAssemblySymmetry__;
+export const AssemblySymmetryParams = {
+    serverUrl: PD.Text(AssemblySymmetry.DefaultServerUrl, { description: 'GraphQL endpoint URL' })
+}
+export type AssemblySymmetryParams = typeof AssemblySymmetryParams
+export type AssemblySymmetryProps = PD.Values<AssemblySymmetryParams>
+
+export type AssemblySymmetryValue = NonNullableArray<NonNullable<NonNullable<AssemblySymmetryQuery['assembly']>['rcsb_struct_symmetry']>>
+
+export const AssemblySymmetryProvider: CustomStructureProperty.Provider<AssemblySymmetryParams, AssemblySymmetryValue> = CustomStructureProperty.createProvider({
+    label: 'Assembly Symmetry',
+    descriptor: CustomPropertyDescriptor({
+        isStatic: true,
+        name: 'rcsb_struct_symmetry',
+        // TODO `cifExport` and `symbol`
+    }),
+    type: 'root',
+    defaultParams: AssemblySymmetryParams,
+    getParams: (data: Structure) => AssemblySymmetryParams,
+    isApplicable: (data: Structure) => AssemblySymmetry.isApplicable(data),
+    obtain: async (ctx: CustomPropertyContext, data: Structure, props: Partial<AssemblySymmetryProps>) => {
+        const p = { ...PD.getDefaultValues(AssemblySymmetryParams), ...props }
+        return await AssemblySymmetry.compute(ctx, data, p)
     }
-}
+})

src/mol-model-props/rcsb/graphql/symmetry.gql.ts

@@ -1,28 +1,25 @@
-export default `query AssemblySymmetry($pdbId: String!) {
-    entry(pdbId: $pdbId) {
-        assemblies {
-            pdbx_struct_assembly {
-                id
-            }
-            rcsb_struct_symmetry {
-                clusters {
-                    avg_rmsd
-                    members {
-                        asym_id
-                        pdbx_struct_oper_list_ids
-                    }
-                }
-                kind
-                oligomeric_state
-                rotation_axes {
-                    start
-                    end
-                    order
+export default /* GraphQL */ `
+query AssemblySymmetry($assembly_id: String!, $entry_id: String!) {
+    assembly(assembly_id: $assembly_id, entry_id: $entry_id) {
+        rcsb_struct_symmetry {
+            clusters {
+                avg_rmsd
+                members {
+                    asym_id
+                    pdbx_struct_oper_list_ids
                 }
-                stoichiometry
-                symbol
-                type
             }
+            kind
+            oligomeric_state
+            rotation_axes {
+                order
+                start
+                end
+            }
+            stoichiometry
+            symbol
+            type
         }
     }
-}`
+}
+`

src/mol-model-props/rcsb/graphql/types.d.ts

@@ -0,0 +1,2777 @@
+/* eslint-disable */
+export type Maybe<T> = T | null;
+
+// Generated in 2020-01-23T15:44:21-08:00
+
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string,
+  String: string,
+  Boolean: boolean,
+  Int: number,
+  Float: number,
+  Date: any,
+  UNREPRESENTABLE: any,
+};
+
+
+export type AuditAuthor = {
+  readonly __typename?: 'AuditAuthor',
+  readonly identifier_ORCID?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly pdbx_ordinal: Scalars['Int'],
+};
+
+export type Cell = {
+  readonly __typename?: 'Cell',
+  readonly Z_PDB?: Maybe<Scalars['Int']>,
+  readonly angle_alpha?: Maybe<Scalars['Float']>,
+  readonly angle_beta?: Maybe<Scalars['Float']>,
+  readonly angle_gamma?: Maybe<Scalars['Float']>,
+  readonly formula_units_Z?: Maybe<Scalars['Int']>,
+  readonly length_a?: Maybe<Scalars['Float']>,
+  readonly length_b?: Maybe<Scalars['Float']>,
+  readonly length_c?: Maybe<Scalars['Float']>,
+  readonly pdbx_unique_axis?: Maybe<Scalars['String']>,
+  readonly volume?: Maybe<Scalars['Float']>,
+};
+
+export type ChemComp = {
+  readonly __typename?: 'ChemComp',
+  readonly formula?: Maybe<Scalars['String']>,
+  readonly formula_weight?: Maybe<Scalars['Float']>,
+  readonly id: Scalars['String'],
+  readonly mon_nstd_parent_comp_id?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly one_letter_code?: Maybe<Scalars['String']>,
+  readonly pdbx_ambiguous_flag?: Maybe<Scalars['String']>,
+  readonly pdbx_formal_charge?: Maybe<Scalars['Int']>,
+  readonly pdbx_initial_date?: Maybe<Scalars['Date']>,
+  readonly pdbx_modified_date?: Maybe<Scalars['Date']>,
+  readonly pdbx_processing_site?: Maybe<Scalars['String']>,
+  readonly pdbx_release_status?: Maybe<Scalars['String']>,
+  readonly pdbx_replaced_by?: Maybe<Scalars['String']>,
+  readonly pdbx_replaces?: Maybe<Scalars['String']>,
+  readonly pdbx_subcomponent_list?: Maybe<Scalars['String']>,
+  readonly three_letter_code?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type Citation = {
+  readonly __typename?: 'Citation',
+  readonly book_id_ISBN?: Maybe<Scalars['String']>,
+  readonly book_publisher?: Maybe<Scalars['String']>,
+  readonly book_publisher_city?: Maybe<Scalars['String']>,
+  readonly book_title?: Maybe<Scalars['String']>,
+  readonly coordinate_linkage?: Maybe<Scalars['String']>,
+  readonly country?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly journal_abbrev?: Maybe<Scalars['String']>,
+  readonly journal_id_ASTM?: Maybe<Scalars['String']>,
+  readonly journal_id_CSD?: Maybe<Scalars['String']>,
+  readonly journal_id_ISSN?: Maybe<Scalars['String']>,
+  readonly journal_issue?: Maybe<Scalars['String']>,
+  readonly journal_volume?: Maybe<Scalars['String']>,
+  readonly language?: Maybe<Scalars['String']>,
+  readonly page_first?: Maybe<Scalars['String']>,
+  readonly page_last?: Maybe<Scalars['String']>,
+  readonly pdbx_database_id_DOI?: Maybe<Scalars['String']>,
+  readonly pdbx_database_id_PubMed?: Maybe<Scalars['Int']>,
+  readonly rcsb_authors?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly rcsb_journal_abbrev?: Maybe<Scalars['String']>,
+  readonly title?: Maybe<Scalars['String']>,
+  readonly unpublished_flag?: Maybe<Scalars['String']>,
+  readonly year?: Maybe<Scalars['Int']>,
+};
+
+export type ClustersMembers = {
+  readonly __typename?: 'ClustersMembers',
+  readonly asym_id: Scalars['String'],
+  readonly pdbx_struct_oper_list_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+};
+
+export type CoreAssembly = {
+  readonly __typename?: 'CoreAssembly',
+  readonly entry?: Maybe<CoreEntry>,
+  readonly pdbx_struct_assembly?: Maybe<PdbxStructAssembly>,
+  readonly pdbx_struct_assembly_auth_evidence?: Maybe<ReadonlyArray<Maybe<PdbxStructAssemblyAuthEvidence>>>,
+  readonly pdbx_struct_assembly_gen?: Maybe<ReadonlyArray<Maybe<PdbxStructAssemblyGen>>>,
+  readonly pdbx_struct_assembly_prop?: Maybe<ReadonlyArray<Maybe<PdbxStructAssemblyProp>>>,
+  readonly pdbx_struct_oper_list?: Maybe<ReadonlyArray<Maybe<PdbxStructOperList>>>,
+  readonly rcsb_assembly_container_identifiers: RcsbAssemblyContainerIdentifiers,
+  readonly rcsb_assembly_info?: Maybe<RcsbAssemblyInfo>,
+  readonly rcsb_id: Scalars['String'],
+  readonly rcsb_latest_revision?: Maybe<RcsbLatestRevision>,
+  readonly rcsb_struct_symmetry?: Maybe<ReadonlyArray<Maybe<RcsbStructSymmetry>>>,
+  readonly rcsb_struct_symmetry_lineage?: Maybe<ReadonlyArray<Maybe<RcsbStructSymmetryLineage>>>,
+  readonly rcsb_struct_symmetry_provenance_code?: Maybe<Scalars['String']>,
+};
+
+export type CoreChemComp = {
+  readonly __typename?: 'CoreChemComp',
+  readonly chem_comp?: Maybe<ChemComp>,
+  readonly drugbank?: Maybe<CoreDrugbank>,
+  readonly pdbx_chem_comp_audit?: Maybe<ReadonlyArray<Maybe<PdbxChemCompAudit>>>,
+  readonly pdbx_chem_comp_descriptor?: Maybe<ReadonlyArray<Maybe<PdbxChemCompDescriptor>>>,
+  readonly pdbx_chem_comp_feature?: Maybe<ReadonlyArray<Maybe<PdbxChemCompFeature>>>,
+  readonly pdbx_chem_comp_identifier?: Maybe<ReadonlyArray<Maybe<PdbxChemCompIdentifier>>>,
+  readonly pdbx_family_prd_audit?: Maybe<ReadonlyArray<Maybe<PdbxFamilyPrdAudit>>>,
+  readonly pdbx_prd_audit?: Maybe<ReadonlyArray<Maybe<PdbxPrdAudit>>>,
+  readonly pdbx_reference_entity_list?: Maybe<ReadonlyArray<Maybe<PdbxReferenceEntityList>>>,
+  readonly pdbx_reference_entity_poly?: Maybe<ReadonlyArray<Maybe<PdbxReferenceEntityPoly>>>,
+  readonly pdbx_reference_entity_poly_link?: Maybe<ReadonlyArray<Maybe<PdbxReferenceEntityPolyLink>>>,
+  readonly pdbx_reference_entity_poly_seq?: Maybe<ReadonlyArray<Maybe<PdbxReferenceEntityPolySeq>>>,
+  readonly pdbx_reference_entity_sequence?: Maybe<ReadonlyArray<Maybe<PdbxReferenceEntitySequence>>>,
+  readonly pdbx_reference_entity_src_nat?: Maybe<ReadonlyArray<Maybe<PdbxReferenceEntitySrcNat>>>,
+  readonly pdbx_reference_molecule?: Maybe<PdbxReferenceMolecule>,
+  readonly pdbx_reference_molecule_annotation?: Maybe<ReadonlyArray<Maybe<PdbxReferenceMoleculeAnnotation>>>,
+  readonly pdbx_reference_molecule_details?: Maybe<ReadonlyArray<Maybe<PdbxReferenceMoleculeDetails>>>,
+  readonly pdbx_reference_molecule_family?: Maybe<PdbxReferenceMoleculeFamily>,
+  readonly pdbx_reference_molecule_features?: Maybe<ReadonlyArray<Maybe<PdbxReferenceMoleculeFeatures>>>,
+  readonly pdbx_reference_molecule_list?: Maybe<ReadonlyArray<Maybe<PdbxReferenceMoleculeList>>>,
+  readonly pdbx_reference_molecule_related_structures?: Maybe<ReadonlyArray<Maybe<PdbxReferenceMoleculeRelatedStructures>>>,
+  readonly pdbx_reference_molecule_synonyms?: Maybe<ReadonlyArray<Maybe<PdbxReferenceMoleculeSynonyms>>>,
+  readonly rcsb_bird_citation?: Maybe<ReadonlyArray<Maybe<RcsbBirdCitation>>>,
+  readonly rcsb_chem_comp_container_identifiers?: Maybe<RcsbChemCompContainerIdentifiers>,
+  readonly rcsb_chem_comp_descriptor?: Maybe<RcsbChemCompDescriptor>,
+  readonly rcsb_chem_comp_info?: Maybe<RcsbChemCompInfo>,
+  readonly rcsb_chem_comp_related?: Maybe<ReadonlyArray<Maybe<RcsbChemCompRelated>>>,
+  readonly rcsb_chem_comp_synonyms?: Maybe<ReadonlyArray<Maybe<RcsbChemCompSynonyms>>>,
+  readonly rcsb_chem_comp_target?: Maybe<ReadonlyArray<Maybe<RcsbChemCompTarget>>>,
+  readonly rcsb_id: Scalars['String'],
+  readonly rcsb_schema_container_identifiers?: Maybe<ReadonlyArray<Maybe<RcsbSchemaContainerIdentifiers>>>,
+};
+
+export type CoreDrugbank = {
+  readonly __typename?: 'CoreDrugbank',
+  readonly drugbank_container_identifiers?: Maybe<DrugbankContainerIdentifiers>,
+  readonly drugbank_info?: Maybe<DrugbankInfo>,
+  readonly drugbank_target?: Maybe<ReadonlyArray<Maybe<DrugbankTarget>>>,
+};
+
+export type CoreEntry = {
+  readonly __typename?: 'CoreEntry',
+  readonly assemblies?: Maybe<ReadonlyArray<Maybe<CoreAssembly>>>,
+  readonly audit_author?: Maybe<ReadonlyArray<Maybe<AuditAuthor>>>,
+  readonly cell?: Maybe<Cell>,
+  readonly citation?: Maybe<ReadonlyArray<Maybe<Citation>>>,
+  readonly diffrn?: Maybe<ReadonlyArray<Maybe<Diffrn>>>,
+  readonly diffrn_detector?: Maybe<ReadonlyArray<Maybe<DiffrnDetector>>>,
+  readonly diffrn_radiation?: Maybe<ReadonlyArray<Maybe<DiffrnRadiation>>>,
+  readonly diffrn_source?: Maybe<ReadonlyArray<Maybe<DiffrnSource>>>,
+  readonly em_2d_crystal_entity?: Maybe<ReadonlyArray<Maybe<Em2dCrystalEntity>>>,
+  readonly em_3d_crystal_entity?: Maybe<ReadonlyArray<Maybe<Em3dCrystalEntity>>>,
+  readonly em_3d_fitting?: Maybe<ReadonlyArray<Maybe<Em3dFitting>>>,
+  readonly em_3d_fitting_list?: Maybe<ReadonlyArray<Maybe<Em3dFittingList>>>,
+  readonly em_3d_reconstruction?: Maybe<ReadonlyArray<Maybe<Em3dReconstruction>>>,
+  readonly em_ctf_correction?: Maybe<ReadonlyArray<Maybe<EmCtfCorrection>>>,
+  readonly em_diffraction?: Maybe<ReadonlyArray<Maybe<EmDiffraction>>>,
+  readonly em_diffraction_shell?: Maybe<ReadonlyArray<Maybe<EmDiffractionShell>>>,
+  readonly em_diffraction_stats?: Maybe<ReadonlyArray<Maybe<EmDiffractionStats>>>,
+  readonly em_embedding?: Maybe<ReadonlyArray<Maybe<EmEmbedding>>>,
+  readonly em_entity_assembly?: Maybe<ReadonlyArray<Maybe<EmEntityAssembly>>>,
+  readonly em_experiment?: Maybe<EmExperiment>,
+  readonly em_helical_entity?: Maybe<ReadonlyArray<Maybe<EmHelicalEntity>>>,
+  readonly em_image_recording?: Maybe<ReadonlyArray<Maybe<EmImageRecording>>>,
+  readonly em_imaging?: Maybe<ReadonlyArray<Maybe<EmImaging>>>,
+  readonly em_particle_selection?: Maybe<ReadonlyArray<Maybe<EmParticleSelection>>>,
+  readonly em_single_particle_entity?: Maybe<ReadonlyArray<Maybe<EmSingleParticleEntity>>>,
+  readonly em_software?: Maybe<ReadonlyArray<Maybe<EmSoftware>>>,
+  readonly em_specimen?: Maybe<ReadonlyArray<Maybe<EmSpecimen>>>,
+  readonly em_staining?: Maybe<ReadonlyArray<Maybe<EmStaining>>>,
+  readonly em_vitrification?: Maybe<ReadonlyArray<Maybe<EmVitrification>>>,
+  readonly entry?: Maybe<Entry>,
+  readonly exptl?: Maybe<ReadonlyArray<Maybe<Exptl>>>,
+  readonly exptl_crystal?: Maybe<ReadonlyArray<Maybe<ExptlCrystal>>>,
+  readonly exptl_crystal_grow?: Maybe<ReadonlyArray<Maybe<ExptlCrystalGrow>>>,
+  readonly nonpolymer_entities?: Maybe<ReadonlyArray<Maybe<CoreNonpolymerEntity>>>,
+  readonly pdbx_SG_project?: Maybe<ReadonlyArray<Maybe<PdbxSgProject>>>,
+  readonly pdbx_audit_revision_category?: Maybe<ReadonlyArray<Maybe<PdbxAuditRevisionCategory>>>,
+  readonly pdbx_audit_revision_details?: Maybe<ReadonlyArray<Maybe<PdbxAuditRevisionDetails>>>,
+  readonly pdbx_audit_revision_group?: Maybe<ReadonlyArray<Maybe<PdbxAuditRevisionGroup>>>,
+  readonly pdbx_audit_revision_history?: Maybe<ReadonlyArray<Maybe<PdbxAuditRevisionHistory>>>,
+  readonly pdbx_audit_revision_item?: Maybe<ReadonlyArray<Maybe<PdbxAuditRevisionItem>>>,
+  readonly pdbx_audit_support?: Maybe<ReadonlyArray<Maybe<PdbxAuditSupport>>>,
+  readonly pdbx_database_PDB_obs_spr?: Maybe<ReadonlyArray<Maybe<PdbxDatabasePdbObsSpr>>>,
+  readonly pdbx_database_related?: Maybe<ReadonlyArray<Maybe<PdbxDatabaseRelated>>>,
+  readonly pdbx_database_status?: Maybe<PdbxDatabaseStatus>,
+  readonly pdbx_deposit_group?: Maybe<ReadonlyArray<Maybe<PdbxDepositGroup>>>,
+  readonly pdbx_molecule_features?: Maybe<ReadonlyArray<Maybe<PdbxMoleculeFeatures>>>,
+  readonly pdbx_nmr_details?: Maybe<PdbxNmrDetails>,
+  readonly pdbx_nmr_ensemble?: Maybe<PdbxNmrEnsemble>,
+  readonly pdbx_nmr_exptl?: Maybe<ReadonlyArray<Maybe<PdbxNmrExptl>>>,
+  readonly pdbx_nmr_exptl_sample_conditions?: Maybe<ReadonlyArray<Maybe<PdbxNmrExptlSampleConditions>>>,
+  readonly pdbx_nmr_refine?: Maybe<ReadonlyArray<Maybe<PdbxNmrRefine>>>,
+  readonly pdbx_nmr_representative?: Maybe<PdbxNmrRepresentative>,
+  readonly pdbx_nmr_sample_details?: Maybe<ReadonlyArray<Maybe<PdbxNmrSampleDetails>>>,
+  readonly pdbx_nmr_software?: Maybe<ReadonlyArray<Maybe<PdbxNmrSoftware>>>,
+  readonly pdbx_nmr_spectrometer?: Maybe<ReadonlyArray<Maybe<PdbxNmrSpectrometer>>>,
+  readonly pdbx_serial_crystallography_data_reduction?: Maybe<ReadonlyArray<Maybe<PdbxSerialCrystallographyDataReduction>>>,
+  readonly pdbx_serial_crystallography_measurement?: Maybe<ReadonlyArray<Maybe<PdbxSerialCrystallographyMeasurement>>>,
+  readonly pdbx_serial_crystallography_sample_delivery?: Maybe<ReadonlyArray<Maybe<PdbxSerialCrystallographySampleDelivery>>>,
+  readonly pdbx_serial_crystallography_sample_delivery_fixed_target?: Maybe<ReadonlyArray<Maybe<PdbxSerialCrystallographySampleDeliveryFixedTarget>>>,
+  readonly pdbx_serial_crystallography_sample_delivery_injection?: Maybe<ReadonlyArray<Maybe<PdbxSerialCrystallographySampleDeliveryInjection>>>,
+  readonly pdbx_soln_scatter?: Maybe<ReadonlyArray<Maybe<PdbxSolnScatter>>>,
+  readonly pdbx_soln_scatter_model?: Maybe<ReadonlyArray<Maybe<PdbxSolnScatterModel>>>,
+  readonly pdbx_vrpt_summary?: Maybe<PdbxVrptSummary>,
+  readonly polymer_entities?: Maybe<ReadonlyArray<Maybe<CorePolymerEntity>>>,
+  readonly pubmed?: Maybe<CorePubmed>,
+  readonly rcsb_accession_info?: Maybe<RcsbAccessionInfo>,
+  readonly rcsb_associated_holdings?: Maybe<CurrentEntry>,
+  readonly rcsb_binding_affinity?: Maybe<ReadonlyArray<Maybe<RcsbBindingAffinity>>>,
+  readonly rcsb_entry_container_identifiers: RcsbEntryContainerIdentifiers,
+  readonly rcsb_entry_info: RcsbEntryInfo,
+  readonly rcsb_external_references?: Maybe<ReadonlyArray<Maybe<RcsbExternalReferences>>>,
+  readonly rcsb_id: Scalars['String'],
+  readonly refine?: Maybe<ReadonlyArray<Maybe<Refine>>>,
+  readonly refine_analyze?: Maybe<ReadonlyArray<Maybe<RefineAnalyze>>>,
+  readonly refine_hist?: Maybe<ReadonlyArray<Maybe<RefineHist>>>,
+  readonly refine_ls_restr?: Maybe<ReadonlyArray<Maybe<RefineLsRestr>>>,
+  readonly reflns?: Maybe<ReadonlyArray<Maybe<Reflns>>>,
+  readonly reflns_shell?: Maybe<ReadonlyArray<Maybe<ReflnsShell>>>,
+  readonly software?: Maybe<ReadonlyArray<Maybe<Software>>>,
+  readonly struct?: Maybe<Struct>,
+  readonly struct_keywords?: Maybe<StructKeywords>,
+  readonly symmetry?: Maybe<Symmetry>,
+};
+
+export type CoreGo = {
+  readonly __typename?: 'CoreGo',
+  readonly rcsb_go_aspect: Scalars['String'],
+  readonly rcsb_go_container_identifiers: RcsbGoContainerIdentifiers,
+  readonly rcsb_go_description?: Maybe<Scalars['String']>,
+  readonly rcsb_go_label: Scalars['String'],
+  readonly rcsb_go_synonyms?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly rcsb_id: Scalars['String'],
+};
+
+export type CoreNonpolymerEntity = {
+  readonly __typename?: 'CoreNonpolymerEntity',
+  readonly nonpolymer_comp?: Maybe<CoreChemComp>,
+  readonly nonpolymer_entity_instances?: Maybe<ReadonlyArray<Maybe<CoreNonpolymerEntityInstance>>>,
+  readonly pdbx_entity_nonpoly?: Maybe<PdbxEntityNonpoly>,
+  readonly prd?: Maybe<CoreChemComp>,
+  readonly rcsb_id: Scalars['String'],
+  readonly rcsb_latest_revision?: Maybe<RcsbLatestRevision>,
+  readonly rcsb_nonpolymer_entity?: Maybe<RcsbNonpolymerEntity>,
+  readonly rcsb_nonpolymer_entity_container_identifiers?: Maybe<RcsbNonpolymerEntityContainerIdentifiers>,
+  readonly rcsb_nonpolymer_entity_feature?: Maybe<ReadonlyArray<Maybe<RcsbNonpolymerEntityFeature>>>,
+  readonly rcsb_nonpolymer_entity_feature_summary?: Maybe<ReadonlyArray<Maybe<RcsbNonpolymerEntityFeatureSummary>>>,
+  readonly rcsb_nonpolymer_entity_keywords?: Maybe<RcsbNonpolymerEntityKeywords>,
+  readonly rcsb_nonpolymer_entity_name_com?: Maybe<ReadonlyArray<Maybe<RcsbNonpolymerEntityNameCom>>>,
+};
+
+export type CoreNonpolymerEntityInstance = {
+  readonly __typename?: 'CoreNonpolymerEntityInstance',
+  readonly pdbx_struct_special_symmetry?: Maybe<ReadonlyArray<Maybe<PdbxStructSpecialSymmetry>>>,
+  readonly rcsb_id: Scalars['String'],
+  readonly rcsb_latest_revision?: Maybe<RcsbLatestRevision>,
+  readonly rcsb_nonpolymer_entity_instance_container_identifiers?: Maybe<RcsbNonpolymerEntityInstanceContainerIdentifiers>,
+  readonly rcsb_nonpolymer_instance_feature?: Maybe<ReadonlyArray<Maybe<RcsbNonpolymerInstanceFeature>>>,
+  readonly rcsb_nonpolymer_instance_feature_summary?: Maybe<ReadonlyArray<Maybe<RcsbNonpolymerInstanceFeatureSummary>>>,
+  readonly rcsb_nonpolymer_struct_conn?: Maybe<ReadonlyArray<Maybe<RcsbNonpolymerStructConn>>>,
+};
+
+export type CorePfam = {
+  readonly __typename?: 'CorePfam',
+  readonly rcsb_id: Scalars['String'],
+  readonly rcsb_pfam_accession: Scalars['String'],
+  readonly rcsb_pfam_clan_id?: Maybe<Scalars['String']>,
+  readonly rcsb_pfam_comment?: Maybe<Scalars['String']>,
+  readonly rcsb_pfam_container_identifiers: RcsbPfamContainerIdentifiers,
+  readonly rcsb_pfam_description?: Maybe<Scalars['String']>,
+  readonly rcsb_pfam_identifier?: Maybe<Scalars['String']>,
+  readonly rcsb_pfam_provenance_code?: Maybe<Scalars['String']>,
+  readonly rcsb_pfam_seed_source?: Maybe<Scalars['String']>,
+};
+
+export type CorePolymerEntity = {
+  readonly __typename?: 'CorePolymerEntity',
+  readonly chem_comp_monomers?: Maybe<ReadonlyArray<Maybe<CoreChemComp>>>,
+  readonly chem_comp_nstd_monomers?: Maybe<ReadonlyArray<Maybe<CoreChemComp>>>,
+  readonly entity_poly?: Maybe<EntityPoly>,
+  readonly entity_src_gen?: Maybe<ReadonlyArray<Maybe<EntitySrcGen>>>,
+  readonly entity_src_nat?: Maybe<ReadonlyArray<Maybe<EntitySrcNat>>>,
+  readonly gos?: Maybe<ReadonlyArray<Maybe<CoreGo>>>,
+  readonly pdbx_entity_src_syn?: Maybe<ReadonlyArray<Maybe<PdbxEntitySrcSyn>>>,
+  readonly pfams?: Maybe<ReadonlyArray<Maybe<CorePfam>>>,
+  readonly polymer_entity_instances?: Maybe<ReadonlyArray<Maybe<CorePolymerEntityInstance>>>,
+  readonly prd?: Maybe<CoreChemComp>,
+  readonly rcsb_cluster_flexibility?: Maybe<RcsbClusterFlexibility>,
+  readonly rcsb_cluster_membership?: Maybe<ReadonlyArray<Maybe<RcsbClusterMembership>>>,
+  readonly rcsb_entity_host_organism?: Maybe<ReadonlyArray<Maybe<RcsbEntityHostOrganism>>>,
+  readonly rcsb_entity_source_organism?: Maybe<ReadonlyArray<Maybe<RcsbEntitySourceOrganism>>>,
+  readonly rcsb_genomic_lineage?: Maybe<ReadonlyArray<Maybe<RcsbGenomicLineage>>>,
+  readonly rcsb_id: Scalars['String'],
+  readonly rcsb_latest_revision?: Maybe<RcsbLatestRevision>,
+  readonly rcsb_membrane_lineage?: Maybe<ReadonlyArray<Maybe<RcsbMembraneLineage>>>,
+  readonly rcsb_membrane_lineage_provenance_code?: Maybe<Scalars['String']>,
+  readonly rcsb_polymer_entity?: Maybe<RcsbPolymerEntity>,
+  readonly rcsb_polymer_entity_align?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityAlign>>>,
+  readonly rcsb_polymer_entity_container_identifiers: RcsbPolymerEntityContainerIdentifiers,
+  readonly rcsb_polymer_entity_feature?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityFeature>>>,
+  readonly rcsb_polymer_entity_feature_summary?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityFeatureSummary>>>,
+  readonly rcsb_polymer_entity_keywords?: Maybe<RcsbPolymerEntityKeywords>,
+  readonly rcsb_polymer_entity_name_com?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityNameCom>>>,
+  readonly rcsb_polymer_entity_name_sys?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityNameSys>>>,
+  readonly uniprots?: Maybe<ReadonlyArray<Maybe<CoreUniprot>>>,
+};
+
+export type CorePolymerEntityInstance = {
+  readonly __typename?: 'CorePolymerEntityInstance',
+  readonly pdbx_struct_special_symmetry?: Maybe<ReadonlyArray<Maybe<PdbxStructSpecialSymmetry>>>,
+  readonly rcsb_id: Scalars['String'],
+  readonly rcsb_latest_revision?: Maybe<RcsbLatestRevision>,
+  readonly rcsb_polymer_entity_instance_container_identifiers?: Maybe<RcsbPolymerEntityInstanceContainerIdentifiers>,
+  readonly rcsb_polymer_instance_feature?: Maybe<ReadonlyArray<Maybe<RcsbPolymerInstanceFeature>>>,
+  readonly rcsb_polymer_instance_feature_summary?: Maybe<ReadonlyArray<Maybe<RcsbPolymerInstanceFeatureSummary>>>,
+  readonly rcsb_polymer_struct_conn?: Maybe<ReadonlyArray<Maybe<RcsbPolymerStructConn>>>,
+};
+
+export type CorePubmed = {
+  readonly __typename?: 'CorePubmed',
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+  readonly rcsb_pubmed_abstract_text?: Maybe<Scalars['String']>,
+  readonly rcsb_pubmed_affiliation_info?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly rcsb_pubmed_central_id?: Maybe<Scalars['String']>,
+  readonly rcsb_pubmed_container_identifiers: RcsbPubmedContainerIdentifiers,
+  readonly rcsb_pubmed_doi?: Maybe<Scalars['String']>,
+  readonly rcsb_pubmed_mesh_descriptors?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly rcsb_pubmed_mesh_descriptors_lineage?: Maybe<ReadonlyArray<Maybe<RcsbPubmedMeshDescriptorsLineage>>>,
+};
+
+export type CoreUniprot = {
+  readonly __typename?: 'CoreUniprot',
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+  readonly rcsb_uniprot_accession?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly rcsb_uniprot_container_identifiers: RcsbUniprotContainerIdentifiers,
+  readonly rcsb_uniprot_entry_name?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly rcsb_uniprot_feature?: Maybe<ReadonlyArray<Maybe<RcsbUniprotFeature>>>,
+  readonly rcsb_uniprot_keyword?: Maybe<ReadonlyArray<Maybe<RcsbUniprotKeyword>>>,
+  readonly rcsb_uniprot_protein?: Maybe<RcsbUniprotProtein>,
+};
+
+export type CurrentEntry = {
+  readonly __typename?: 'CurrentEntry',
+  readonly rcsb_id: Scalars['String'],
+  readonly rcsb_repository_holdings_current?: Maybe<RcsbRepositoryHoldingsCurrent>,
+  readonly rcsb_repository_holdings_current_entry_container_identifiers?: Maybe<RcsbRepositoryHoldingsCurrentEntryContainerIdentifiers>,
+};
+
+
+export type Diffrn = {
+  readonly __typename?: 'Diffrn',
+  readonly ambient_pressure?: Maybe<Scalars['Float']>,
+  readonly ambient_temp?: Maybe<Scalars['Float']>,
+  readonly ambient_temp_details?: Maybe<Scalars['String']>,
+  readonly crystal_id?: Maybe<Scalars['String']>,
+  readonly crystal_support?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly pdbx_serial_crystal_experiment?: Maybe<Scalars['String']>,
+};
+
+export type DiffrnDetector = {
+  readonly __typename?: 'DiffrnDetector',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly detector?: Maybe<Scalars['String']>,
+  readonly diffrn_id: Scalars['String'],
+  readonly pdbx_collection_date?: Maybe<Scalars['Date']>,
+  readonly pdbx_frequency?: Maybe<Scalars['Float']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type DiffrnRadiation = {
+  readonly __typename?: 'DiffrnRadiation',
+  readonly collimation?: Maybe<Scalars['String']>,
+  readonly diffrn_id: Scalars['String'],
+  readonly monochromator?: Maybe<Scalars['String']>,
+  readonly pdbx_diffrn_protocol?: Maybe<Scalars['String']>,
+  readonly pdbx_monochromatic_or_laue_m_l?: Maybe<Scalars['String']>,
+  readonly pdbx_scattering_type?: Maybe<Scalars['String']>,
+  readonly pdbx_wavelength?: Maybe<Scalars['String']>,
+  readonly pdbx_wavelength_list?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+  readonly wavelength_id?: Maybe<Scalars['String']>,
+};
+
+export type DiffrnSource = {
+  readonly __typename?: 'DiffrnSource',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly diffrn_id: Scalars['String'],
+  readonly pdbx_synchrotron_beamline?: Maybe<Scalars['String']>,
+  readonly pdbx_synchrotron_site?: Maybe<Scalars['String']>,
+  readonly pdbx_wavelength?: Maybe<Scalars['String']>,
+  readonly pdbx_wavelength_list?: Maybe<Scalars['String']>,
+  readonly source?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type DrugbankContainerIdentifiers = {
+  readonly __typename?: 'DrugbankContainerIdentifiers',
+  readonly drugbank_id: Scalars['String'],
+};
+
+export type DrugbankInfo = {
+  readonly __typename?: 'DrugbankInfo',
+  readonly affected_organisms?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly atc_codes?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly brand_names?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly cas_number?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly drug_categories?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly drug_groups?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly drugbank_id: Scalars['String'],
+  readonly indication?: Maybe<Scalars['String']>,
+  readonly mechanism_of_action?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly pharmacology?: Maybe<Scalars['String']>,
+  readonly synonyms?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+};
+
+export type DrugbankTarget = {
+  readonly __typename?: 'DrugbankTarget',
+  readonly interaction_type?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly organism_common_name?: Maybe<Scalars['String']>,
+  readonly reference_database_accession_code?: Maybe<Scalars['String']>,
+  readonly reference_database_name?: Maybe<Scalars['String']>,
+  readonly seq_one_letter_code?: Maybe<Scalars['String']>,
+  readonly target_actions?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+};
+
+export type Em2dCrystalEntity = {
+  readonly __typename?: 'Em2dCrystalEntity',
+  readonly angle_gamma?: Maybe<Scalars['Float']>,
+  readonly c_sampling_length?: Maybe<Scalars['Float']>,
+  readonly id: Scalars['String'],
+  readonly image_processing_id: Scalars['String'],
+  readonly length_a?: Maybe<Scalars['Float']>,
+  readonly length_b?: Maybe<Scalars['Float']>,
+  readonly length_c?: Maybe<Scalars['Float']>,
+  readonly space_group_name_H_M?: Maybe<Scalars['String']>,
+};
+
+export type Em3dCrystalEntity = {
+  readonly __typename?: 'Em3dCrystalEntity',
+  readonly angle_alpha?: Maybe<Scalars['Float']>,
+  readonly angle_beta?: Maybe<Scalars['Float']>,
+  readonly angle_gamma?: Maybe<Scalars['Float']>,
+  readonly id: Scalars['String'],
+  readonly image_processing_id: Scalars['String'],
+  readonly length_a?: Maybe<Scalars['Float']>,
+  readonly length_b?: Maybe<Scalars['Float']>,
+  readonly length_c?: Maybe<Scalars['Float']>,
+  readonly space_group_name?: Maybe<Scalars['String']>,
+  readonly space_group_num?: Maybe<Scalars['Int']>,
+};
+
+export type Em3dFitting = {
+  readonly __typename?: 'Em3dFitting',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly method?: Maybe<Scalars['String']>,
+  readonly overall_b_value?: Maybe<Scalars['Float']>,
+  readonly ref_protocol?: Maybe<Scalars['String']>,
+  readonly ref_space?: Maybe<Scalars['String']>,
+  readonly target_criteria?: Maybe<Scalars['String']>,
+};
+
+export type Em3dFittingList = {
+  readonly __typename?: 'Em3dFittingList',
+  readonly _3d_fitting_id: Scalars['String'],
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly pdb_chain_id?: Maybe<Scalars['String']>,
+  readonly pdb_chain_residue_range?: Maybe<Scalars['String']>,
+  readonly pdb_entry_id?: Maybe<Scalars['String']>,
+};
+
+export type Em3dReconstruction = {
+  readonly __typename?: 'Em3dReconstruction',
+  readonly actual_pixel_size?: Maybe<Scalars['Float']>,
+  readonly algorithm?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly image_processing_id: Scalars['String'],
+  readonly magnification_calibration?: Maybe<Scalars['String']>,
+  readonly method?: Maybe<Scalars['String']>,
+  readonly nominal_pixel_size?: Maybe<Scalars['Float']>,
+  readonly num_class_averages?: Maybe<Scalars['Int']>,
+  readonly num_particles?: Maybe<Scalars['Int']>,
+  readonly refinement_type?: Maybe<Scalars['String']>,
+  readonly resolution?: Maybe<Scalars['Float']>,
+  readonly resolution_method?: Maybe<Scalars['String']>,
+  readonly symmetry_type?: Maybe<Scalars['String']>,
+};
+
+export type EmCtfCorrection = {
+  readonly __typename?: 'EmCtfCorrection',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly em_image_processing_id?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type EmDiffraction = {
+  readonly __typename?: 'EmDiffraction',
+  readonly camera_length?: Maybe<Scalars['Float']>,
+  readonly id: Scalars['String'],
+  readonly imaging_id?: Maybe<Scalars['String']>,
+  readonly tilt_angle_list?: Maybe<Scalars['String']>,
+};
+
+export type EmDiffractionShell = {
+  readonly __typename?: 'EmDiffractionShell',
+  readonly em_diffraction_stats_id?: Maybe<Scalars['String']>,
+  readonly fourier_space_coverage?: Maybe<Scalars['Float']>,
+  readonly high_resolution?: Maybe<Scalars['Float']>,
+  readonly id: Scalars['String'],
+  readonly low_resolution?: Maybe<Scalars['Float']>,
+  readonly multiplicity?: Maybe<Scalars['Float']>,
+  readonly num_structure_factors?: Maybe<Scalars['Int']>,
+  readonly phase_residual?: Maybe<Scalars['Float']>,
+};
+
+export type EmDiffractionStats = {
+  readonly __typename?: 'EmDiffractionStats',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly fourier_space_coverage?: Maybe<Scalars['Float']>,
+  readonly high_resolution?: Maybe<Scalars['Float']>,
+  readonly id: Scalars['String'],
+  readonly image_processing_id?: Maybe<Scalars['String']>,
+  readonly num_intensities_measured?: Maybe<Scalars['Int']>,
+  readonly num_structure_factors?: Maybe<Scalars['Int']>,
+  readonly overall_phase_error?: Maybe<Scalars['Float']>,
+  readonly overall_phase_residual?: Maybe<Scalars['Float']>,
+  readonly phase_error_rejection_criteria?: Maybe<Scalars['String']>,
+  readonly r_merge?: Maybe<Scalars['Float']>,
+  readonly r_sym?: Maybe<Scalars['Float']>,
+};
+
+export type EmEmbedding = {
+  readonly __typename?: 'EmEmbedding',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly material?: Maybe<Scalars['String']>,
+  readonly specimen_id?: Maybe<Scalars['String']>,
+};
+
+export type EmEntityAssembly = {
+  readonly __typename?: 'EmEntityAssembly',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly entity_id_list?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly id: Scalars['String'],
+  readonly name?: Maybe<Scalars['String']>,
+  readonly oligomeric_details?: Maybe<Scalars['String']>,
+  readonly parent_id?: Maybe<Scalars['Int']>,
+  readonly source?: Maybe<Scalars['String']>,
+  readonly synonym?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type EmExperiment = {
+  readonly __typename?: 'EmExperiment',
+  readonly aggregation_state?: Maybe<Scalars['String']>,
+  readonly entity_assembly_id?: Maybe<Scalars['String']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly reconstruction_method?: Maybe<Scalars['String']>,
+};
+
+export type EmHelicalEntity = {
+  readonly __typename?: 'EmHelicalEntity',
+  readonly angular_rotation_per_subunit?: Maybe<Scalars['Float']>,
+  readonly axial_rise_per_subunit?: Maybe<Scalars['Float']>,
+  readonly axial_symmetry?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly image_processing_id: Scalars['String'],
+};
+
+export type EmImageRecording = {
+  readonly __typename?: 'EmImageRecording',
+  readonly average_exposure_time?: Maybe<Scalars['Float']>,
+  readonly avg_electron_dose_per_image?: Maybe<Scalars['Float']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly detector_mode?: Maybe<Scalars['String']>,
+  readonly film_or_detector_model?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly imaging_id: Scalars['String'],
+  readonly num_diffraction_images?: Maybe<Scalars['Int']>,
+  readonly num_grids_imaged?: Maybe<Scalars['Int']>,
+  readonly num_real_images?: Maybe<Scalars['Int']>,
+};
+
+export type EmImaging = {
+  readonly __typename?: 'EmImaging',
+  readonly accelerating_voltage?: Maybe<Scalars['Int']>,
+  readonly alignment_procedure?: Maybe<Scalars['String']>,
+  readonly astigmatism?: Maybe<Scalars['String']>,
+  readonly c2_aperture_diameter?: Maybe<Scalars['Float']>,
+  readonly calibrated_defocus_max?: Maybe<Scalars['Float']>,
+  readonly calibrated_defocus_min?: Maybe<Scalars['Float']>,
+  readonly calibrated_magnification?: Maybe<Scalars['Int']>,
+  readonly cryogen?: Maybe<Scalars['String']>,
+  readonly date?: Maybe<Scalars['Date']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly detector_distance?: Maybe<Scalars['Float']>,
+  readonly electron_beam_tilt_params?: Maybe<Scalars['String']>,
+  readonly electron_source?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly illumination_mode?: Maybe<Scalars['String']>,
+  readonly microscope_model?: Maybe<Scalars['String']>,
+  readonly mode?: Maybe<Scalars['String']>,
+  readonly nominal_cs?: Maybe<Scalars['Float']>,
+  readonly nominal_defocus_max?: Maybe<Scalars['Float']>,
+  readonly nominal_defocus_min?: Maybe<Scalars['Float']>,
+  readonly nominal_magnification?: Maybe<Scalars['Int']>,
+  readonly recording_temperature_maximum?: Maybe<Scalars['Float']>,
+  readonly recording_temperature_minimum?: Maybe<Scalars['Float']>,
+  readonly residual_tilt?: Maybe<Scalars['Float']>,
+  readonly specimen_holder_model?: Maybe<Scalars['String']>,
+  readonly specimen_holder_type?: Maybe<Scalars['String']>,
+  readonly specimen_id?: Maybe<Scalars['String']>,
+  readonly temperature?: Maybe<Scalars['Float']>,
+  readonly tilt_angle_max?: Maybe<Scalars['Float']>,
+  readonly tilt_angle_min?: Maybe<Scalars['Float']>,
+};
+
+export type EmParticleSelection = {
+  readonly __typename?: 'EmParticleSelection',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly image_processing_id: Scalars['String'],
+  readonly num_particles_selected?: Maybe<Scalars['Int']>,
+};
+
+export type EmSingleParticleEntity = {
+  readonly __typename?: 'EmSingleParticleEntity',
+  readonly id: Scalars['String'],
+  readonly image_processing_id: Scalars['String'],
+  readonly point_symmetry?: Maybe<Scalars['String']>,
+};
+
+export type EmSoftware = {
+  readonly __typename?: 'EmSoftware',
+  readonly category?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly fitting_id?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly image_processing_id?: Maybe<Scalars['String']>,
+  readonly imaging_id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly version?: Maybe<Scalars['String']>,
+};
+
+export type EmSpecimen = {
+  readonly __typename?: 'EmSpecimen',
+  readonly concentration?: Maybe<Scalars['Float']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly embedding_applied?: Maybe<Scalars['String']>,
+  readonly experiment_id: Scalars['String'],
+  readonly id: Scalars['String'],
+  readonly shadowing_applied?: Maybe<Scalars['String']>,
+  readonly staining_applied?: Maybe<Scalars['String']>,
+  readonly vitrification_applied?: Maybe<Scalars['String']>,
+};
+
+export type EmStaining = {
+  readonly __typename?: 'EmStaining',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly material?: Maybe<Scalars['String']>,
+  readonly specimen_id?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type EmVitrification = {
+  readonly __typename?: 'EmVitrification',
+  readonly chamber_temperature?: Maybe<Scalars['Float']>,
+  readonly cryogen_name?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly humidity?: Maybe<Scalars['Float']>,
+  readonly id: Scalars['String'],
+  readonly instrument?: Maybe<Scalars['String']>,
+  readonly method?: Maybe<Scalars['String']>,
+  readonly specimen_id: Scalars['String'],
+  readonly temp?: Maybe<Scalars['Float']>,
+  readonly time_resolved_state?: Maybe<Scalars['String']>,
+};
+
+export type EntityPoly = {
+  readonly __typename?: 'EntityPoly',
+  readonly nstd_linkage?: Maybe<Scalars['String']>,
+  readonly nstd_monomer?: Maybe<Scalars['String']>,
+  readonly pdbx_seq_one_letter_code?: Maybe<Scalars['String']>,
+  readonly pdbx_seq_one_letter_code_can?: Maybe<Scalars['String']>,
+  readonly pdbx_strand_id?: Maybe<Scalars['String']>,
+  readonly pdbx_target_identifier?: Maybe<Scalars['String']>,
+  readonly rcsb_artifact_monomer_count?: Maybe<Scalars['Int']>,
+  readonly rcsb_conflict_count?: Maybe<Scalars['Int']>,
+  readonly rcsb_deletion_count?: Maybe<Scalars['Int']>,
+  readonly rcsb_entity_polymer_type?: Maybe<Scalars['String']>,
+  readonly rcsb_insertion_count?: Maybe<Scalars['Int']>,
+  readonly rcsb_mutation_count?: Maybe<Scalars['Int']>,
+  readonly rcsb_non_std_monomer_count?: Maybe<Scalars['Int']>,
+  readonly rcsb_non_std_monomers?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly rcsb_prd_id?: Maybe<Scalars['String']>,
+  readonly rcsb_sample_sequence_length?: Maybe<Scalars['Int']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type EntitySrcGen = {
+  readonly __typename?: 'EntitySrcGen',
+  readonly expression_system_id?: Maybe<Scalars['String']>,
+  readonly gene_src_common_name?: Maybe<Scalars['String']>,
+  readonly gene_src_details?: Maybe<Scalars['String']>,
+  readonly gene_src_genus?: Maybe<Scalars['String']>,
+  readonly gene_src_species?: Maybe<Scalars['String']>,
+  readonly gene_src_strain?: Maybe<Scalars['String']>,
+  readonly gene_src_tissue?: Maybe<Scalars['String']>,
+  readonly gene_src_tissue_fraction?: Maybe<Scalars['String']>,
+  readonly host_org_common_name?: Maybe<Scalars['String']>,
+  readonly host_org_details?: Maybe<Scalars['String']>,
+  readonly host_org_genus?: Maybe<Scalars['String']>,
+  readonly host_org_species?: Maybe<Scalars['String']>,
+  readonly pdbx_alt_source_flag?: Maybe<Scalars['String']>,
+  readonly pdbx_beg_seq_num?: Maybe<Scalars['Int']>,
+  readonly pdbx_description?: Maybe<Scalars['String']>,
+  readonly pdbx_end_seq_num?: Maybe<Scalars['Int']>,
+  readonly pdbx_gene_src_atcc?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_cell?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_cell_line?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_cellular_location?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_fragment?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_gene?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_ncbi_taxonomy_id?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_organ?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_organelle?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_scientific_name?: Maybe<Scalars['String']>,
+  readonly pdbx_gene_src_variant?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_atcc?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_cell?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_cell_line?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_cellular_location?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_culture_collection?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_gene?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_ncbi_taxonomy_id?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_organ?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_organelle?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_scientific_name?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_strain?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_tissue?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_tissue_fraction?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_variant?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_vector?: Maybe<Scalars['String']>,
+  readonly pdbx_host_org_vector_type?: Maybe<Scalars['String']>,
+  readonly pdbx_seq_type?: Maybe<Scalars['String']>,
+  readonly pdbx_src_id: Scalars['Int'],
+  readonly plasmid_details?: Maybe<Scalars['String']>,
+  readonly plasmid_name?: Maybe<Scalars['String']>,
+};
+
+export type EntitySrcNat = {
+  readonly __typename?: 'EntitySrcNat',
+  readonly common_name?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly genus?: Maybe<Scalars['String']>,
+  readonly pdbx_alt_source_flag?: Maybe<Scalars['String']>,
+  readonly pdbx_atcc?: Maybe<Scalars['String']>,
+  readonly pdbx_beg_seq_num?: Maybe<Scalars['Int']>,
+  readonly pdbx_cell?: Maybe<Scalars['String']>,
+  readonly pdbx_cell_line?: Maybe<Scalars['String']>,
+  readonly pdbx_cellular_location?: Maybe<Scalars['String']>,
+  readonly pdbx_end_seq_num?: Maybe<Scalars['Int']>,
+  readonly pdbx_fragment?: Maybe<Scalars['String']>,
+  readonly pdbx_ncbi_taxonomy_id?: Maybe<Scalars['String']>,
+  readonly pdbx_organ?: Maybe<Scalars['String']>,
+  readonly pdbx_organelle?: Maybe<Scalars['String']>,
+  readonly pdbx_organism_scientific?: Maybe<Scalars['String']>,
+  readonly pdbx_plasmid_details?: Maybe<Scalars['String']>,
+  readonly pdbx_plasmid_name?: Maybe<Scalars['String']>,
+  readonly pdbx_secretion?: Maybe<Scalars['String']>,
+  readonly pdbx_src_id: Scalars['Int'],
+  readonly pdbx_variant?: Maybe<Scalars['String']>,
+  readonly species?: Maybe<Scalars['String']>,
+  readonly strain?: Maybe<Scalars['String']>,
+  readonly tissue?: Maybe<Scalars['String']>,
+  readonly tissue_fraction?: Maybe<Scalars['String']>,
+};
+
+export type Entry = {
+  readonly __typename?: 'Entry',
+  readonly id: Scalars['String'],
+};
+
+export type Exptl = {
+  readonly __typename?: 'Exptl',
+  readonly crystals_number?: Maybe<Scalars['Int']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly method: Scalars['String'],
+  readonly method_details?: Maybe<Scalars['String']>,
+};
+
+export type ExptlCrystal = {
+  readonly __typename?: 'ExptlCrystal',
+  readonly colour?: Maybe<Scalars['String']>,
+  readonly density_Matthews?: Maybe<Scalars['Float']>,
+  readonly density_meas?: Maybe<Scalars['Float']>,
+  readonly density_percent_sol?: Maybe<Scalars['Float']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly pdbx_mosaicity?: Maybe<Scalars['Float']>,
+  readonly pdbx_mosaicity_esd?: Maybe<Scalars['Float']>,
+  readonly preparation?: Maybe<Scalars['String']>,
+};
+
+export type ExptlCrystalGrow = {
+  readonly __typename?: 'ExptlCrystalGrow',
+  readonly crystal_id: Scalars['String'],
+  readonly details?: Maybe<Scalars['String']>,
+  readonly method?: Maybe<Scalars['String']>,
+  readonly pH?: Maybe<Scalars['Float']>,
+  readonly pdbx_details?: Maybe<Scalars['String']>,
+  readonly pdbx_pH_range?: Maybe<Scalars['String']>,
+  readonly temp?: Maybe<Scalars['Float']>,
+  readonly temp_details?: Maybe<Scalars['String']>,
+};
+
+export type GeneName = {
+  readonly __typename?: 'GeneName',
+  readonly type?: Maybe<Scalars['String']>,
+  readonly value?: Maybe<Scalars['String']>,
+};
+
+export type PdbxAuditRevisionCategory = {
+  readonly __typename?: 'PdbxAuditRevisionCategory',
+  readonly category?: Maybe<Scalars['String']>,
+  readonly data_content_type: Scalars['String'],
+  readonly ordinal: Scalars['Int'],
+  readonly revision_ordinal: Scalars['Int'],
+};
+
+export type PdbxAuditRevisionDetails = {
+  readonly __typename?: 'PdbxAuditRevisionDetails',
+  readonly data_content_type: Scalars['String'],
+  readonly ordinal: Scalars['Int'],
+  readonly provider?: Maybe<Scalars['String']>,
+  readonly revision_ordinal: Scalars['Int'],
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxAuditRevisionGroup = {
+  readonly __typename?: 'PdbxAuditRevisionGroup',
+  readonly data_content_type: Scalars['String'],
+  readonly group?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly revision_ordinal: Scalars['Int'],
+};
+
+export type PdbxAuditRevisionHistory = {
+  readonly __typename?: 'PdbxAuditRevisionHistory',
+  readonly data_content_type: Scalars['String'],
+  readonly major_revision?: Maybe<Scalars['Int']>,
+  readonly minor_revision?: Maybe<Scalars['Int']>,
+  readonly ordinal: Scalars['Int'],
+  readonly revision_date?: Maybe<Scalars['Date']>,
+};
+
+export type PdbxAuditRevisionItem = {
+  readonly __typename?: 'PdbxAuditRevisionItem',
+  readonly data_content_type: Scalars['String'],
+  readonly item?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly revision_ordinal: Scalars['Int'],
+};
+
+export type PdbxAuditSupport = {
+  readonly __typename?: 'PdbxAuditSupport',
+  readonly country?: Maybe<Scalars['String']>,
+  readonly funding_organization?: Maybe<Scalars['String']>,
+  readonly grant_number?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+};
+
+export type PdbxChemCompAudit = {
+  readonly __typename?: 'PdbxChemCompAudit',
+  readonly action_type?: Maybe<Scalars['String']>,
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly date?: Maybe<Scalars['Date']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+};
+
+export type PdbxChemCompDescriptor = {
+  readonly __typename?: 'PdbxChemCompDescriptor',
+  readonly comp_id: Scalars['String'],
+  readonly descriptor?: Maybe<Scalars['String']>,
+  readonly program: Scalars['String'],
+  readonly program_version: Scalars['String'],
+  readonly type: Scalars['String'],
+};
+
+export type PdbxChemCompFeature = {
+  readonly __typename?: 'PdbxChemCompFeature',
+  readonly comp_id: Scalars['String'],
+  readonly source: Scalars['String'],
+  readonly type: Scalars['String'],
+  readonly value: Scalars['String'],
+};
+
+export type PdbxChemCompIdentifier = {
+  readonly __typename?: 'PdbxChemCompIdentifier',
+  readonly comp_id: Scalars['String'],
+  readonly identifier?: Maybe<Scalars['String']>,
+  readonly program: Scalars['String'],
+  readonly program_version: Scalars['String'],
+  readonly type: Scalars['String'],
+};
+
+export type PdbxDatabasePdbObsSpr = {
+  readonly __typename?: 'PdbxDatabasePDBObsSpr',
+  readonly date?: Maybe<Scalars['Date']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly pdb_id: Scalars['String'],
+  readonly replace_pdb_id: Scalars['String'],
+};
+
+export type PdbxDatabaseRelated = {
+  readonly __typename?: 'PdbxDatabaseRelated',
+  readonly content_type: Scalars['String'],
+  readonly db_id: Scalars['String'],
+  readonly db_name: Scalars['String'],
+  readonly details?: Maybe<Scalars['String']>,
+};
+
+export type PdbxDatabaseStatus = {
+  readonly __typename?: 'PdbxDatabaseStatus',
+  readonly SG_entry?: Maybe<Scalars['String']>,
+  readonly deposit_site?: Maybe<Scalars['String']>,
+  readonly methods_development_category?: Maybe<Scalars['String']>,
+  readonly pdb_format_compatible?: Maybe<Scalars['String']>,
+  readonly process_site?: Maybe<Scalars['String']>,
+  readonly recvd_initial_deposition_date?: Maybe<Scalars['Date']>,
+  readonly status_code?: Maybe<Scalars['String']>,
+  readonly status_code_cs?: Maybe<Scalars['String']>,
+  readonly status_code_mr?: Maybe<Scalars['String']>,
+  readonly status_code_sf?: Maybe<Scalars['String']>,
+};
+
+export type PdbxDepositGroup = {
+  readonly __typename?: 'PdbxDepositGroup',
+  readonly group_description?: Maybe<Scalars['String']>,
+  readonly group_id: Scalars['String'],
+  readonly group_title?: Maybe<Scalars['String']>,
+  readonly group_type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxEntityNonpoly = {
+  readonly __typename?: 'PdbxEntityNonpoly',
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly entity_id: Scalars['String'],
+  readonly name?: Maybe<Scalars['String']>,
+  readonly rcsb_prd_id?: Maybe<Scalars['String']>,
+};
+
+export type PdbxEntitySrcSyn = {
+  readonly __typename?: 'PdbxEntitySrcSyn',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly ncbi_taxonomy_id?: Maybe<Scalars['String']>,
+  readonly organism_common_name?: Maybe<Scalars['String']>,
+  readonly organism_scientific?: Maybe<Scalars['String']>,
+  readonly pdbx_alt_source_flag?: Maybe<Scalars['String']>,
+  readonly pdbx_beg_seq_num?: Maybe<Scalars['Int']>,
+  readonly pdbx_end_seq_num?: Maybe<Scalars['Int']>,
+  readonly pdbx_src_id: Scalars['Int'],
+};
+
+export type PdbxFamilyPrdAudit = {
+  readonly __typename?: 'PdbxFamilyPrdAudit',
+  readonly action_type: Scalars['String'],
+  readonly annotator?: Maybe<Scalars['String']>,
+  readonly date: Scalars['Date'],
+  readonly details?: Maybe<Scalars['String']>,
+  readonly family_prd_id: Scalars['String'],
+  readonly processing_site?: Maybe<Scalars['String']>,
+};
+
+export type PdbxMoleculeFeatures = {
+  readonly __typename?: 'PdbxMoleculeFeatures',
+  readonly class?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly prd_id: Scalars['String'],
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxNmrDetails = {
+  readonly __typename?: 'PdbxNmrDetails',
+  readonly text?: Maybe<Scalars['String']>,
+};
+
+export type PdbxNmrEnsemble = {
+  readonly __typename?: 'PdbxNmrEnsemble',
+  readonly average_constraint_violations_per_residue?: Maybe<Scalars['Int']>,
+  readonly average_constraints_per_residue?: Maybe<Scalars['Int']>,
+  readonly average_distance_constraint_violation?: Maybe<Scalars['Float']>,
+  readonly average_torsion_angle_constraint_violation?: Maybe<Scalars['Float']>,
+  readonly conformer_selection_criteria?: Maybe<Scalars['String']>,
+  readonly conformers_calculated_total_number?: Maybe<Scalars['Int']>,
+  readonly conformers_submitted_total_number?: Maybe<Scalars['Int']>,
+  readonly distance_constraint_violation_method?: Maybe<Scalars['String']>,
+  readonly maximum_distance_constraint_violation?: Maybe<Scalars['Float']>,
+  readonly maximum_lower_distance_constraint_violation?: Maybe<Scalars['Float']>,
+  readonly maximum_torsion_angle_constraint_violation?: Maybe<Scalars['Float']>,
+  readonly maximum_upper_distance_constraint_violation?: Maybe<Scalars['Float']>,
+  readonly representative_conformer?: Maybe<Scalars['Int']>,
+  readonly torsion_angle_constraint_violation_method?: Maybe<Scalars['String']>,
+};
+
+export type PdbxNmrExptl = {
+  readonly __typename?: 'PdbxNmrExptl',
+  readonly conditions_id: Scalars['String'],
+  readonly experiment_id: Scalars['String'],
+  readonly sample_state?: Maybe<Scalars['String']>,
+  readonly solution_id: Scalars['String'],
+  readonly spectrometer_id?: Maybe<Scalars['Int']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxNmrExptlSampleConditions = {
+  readonly __typename?: 'PdbxNmrExptlSampleConditions',
+  readonly conditions_id: Scalars['String'],
+  readonly details?: Maybe<Scalars['String']>,
+  readonly ionic_strength?: Maybe<Scalars['String']>,
+  readonly ionic_strength_err?: Maybe<Scalars['Float']>,
+  readonly ionic_strength_units?: Maybe<Scalars['String']>,
+  readonly label?: Maybe<Scalars['String']>,
+  readonly pH?: Maybe<Scalars['String']>,
+  readonly pH_err?: Maybe<Scalars['Float']>,
+  readonly pH_units?: Maybe<Scalars['String']>,
+  readonly pressure?: Maybe<Scalars['String']>,
+  readonly pressure_err?: Maybe<Scalars['Float']>,
+  readonly pressure_units?: Maybe<Scalars['String']>,
+  readonly temperature?: Maybe<Scalars['String']>,
+  readonly temperature_err?: Maybe<Scalars['Float']>,
+  readonly temperature_units?: Maybe<Scalars['String']>,
+};
+
+export type PdbxNmrRefine = {
+  readonly __typename?: 'PdbxNmrRefine',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly method?: Maybe<Scalars['String']>,
+  readonly software_ordinal: Scalars['Int'],
+};
+
+export type PdbxNmrRepresentative = {
+  readonly __typename?: 'PdbxNmrRepresentative',
+  readonly conformer_id?: Maybe<Scalars['String']>,
+  readonly selection_criteria?: Maybe<Scalars['String']>,
+};
+
+export type PdbxNmrSampleDetails = {
+  readonly __typename?: 'PdbxNmrSampleDetails',
+  readonly contents?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly label?: Maybe<Scalars['String']>,
+  readonly solution_id: Scalars['String'],
+  readonly solvent_system?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxNmrSoftware = {
+  readonly __typename?: 'PdbxNmrSoftware',
+  readonly authors?: Maybe<Scalars['String']>,
+  readonly classification?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly version?: Maybe<Scalars['String']>,
+};
+
+export type PdbxNmrSpectrometer = {
+  readonly __typename?: 'PdbxNmrSpectrometer',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly field_strength?: Maybe<Scalars['Float']>,
+  readonly manufacturer?: Maybe<Scalars['String']>,
+  readonly model?: Maybe<Scalars['String']>,
+  readonly spectrometer_id: Scalars['String'],
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxPrdAudit = {
+  readonly __typename?: 'PdbxPrdAudit',
+  readonly action_type: Scalars['String'],
+  readonly annotator?: Maybe<Scalars['String']>,
+  readonly date: Scalars['Date'],
+  readonly details?: Maybe<Scalars['String']>,
+  readonly prd_id: Scalars['String'],
+  readonly processing_site?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceEntityList = {
+  readonly __typename?: 'PdbxReferenceEntityList',
+  readonly component_id: Scalars['Int'],
+  readonly details?: Maybe<Scalars['String']>,
+  readonly prd_id: Scalars['String'],
+  readonly ref_entity_id: Scalars['String'],
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceEntityPoly = {
+  readonly __typename?: 'PdbxReferenceEntityPoly',
+  readonly db_code?: Maybe<Scalars['String']>,
+  readonly db_name?: Maybe<Scalars['String']>,
+  readonly prd_id: Scalars['String'],
+  readonly ref_entity_id: Scalars['String'],
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceEntityPolyLink = {
+  readonly __typename?: 'PdbxReferenceEntityPolyLink',
+  readonly atom_id_1?: Maybe<Scalars['String']>,
+  readonly atom_id_2?: Maybe<Scalars['String']>,
+  readonly comp_id_1?: Maybe<Scalars['String']>,
+  readonly comp_id_2?: Maybe<Scalars['String']>,
+  readonly component_id: Scalars['Int'],
+  readonly entity_seq_num_1?: Maybe<Scalars['Int']>,
+  readonly entity_seq_num_2?: Maybe<Scalars['Int']>,
+  readonly link_id: Scalars['Int'],
+  readonly prd_id: Scalars['String'],
+  readonly ref_entity_id: Scalars['String'],
+  readonly value_order?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceEntityPolySeq = {
+  readonly __typename?: 'PdbxReferenceEntityPolySeq',
+  readonly hetero: Scalars['String'],
+  readonly mon_id: Scalars['String'],
+  readonly num: Scalars['Int'],
+  readonly observed?: Maybe<Scalars['String']>,
+  readonly parent_mon_id?: Maybe<Scalars['String']>,
+  readonly prd_id: Scalars['String'],
+  readonly ref_entity_id: Scalars['String'],
+};
+
+export type PdbxReferenceEntitySequence = {
+  readonly __typename?: 'PdbxReferenceEntitySequence',
+  readonly NRP_flag?: Maybe<Scalars['String']>,
+  readonly one_letter_codes?: Maybe<Scalars['String']>,
+  readonly prd_id: Scalars['String'],
+  readonly ref_entity_id: Scalars['String'],
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceEntitySrcNat = {
+  readonly __typename?: 'PdbxReferenceEntitySrcNat',
+  readonly atcc?: Maybe<Scalars['String']>,
+  readonly db_code?: Maybe<Scalars['String']>,
+  readonly db_name?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly organism_scientific?: Maybe<Scalars['String']>,
+  readonly prd_id: Scalars['String'],
+  readonly ref_entity_id: Scalars['String'],
+  readonly source?: Maybe<Scalars['String']>,
+  readonly source_id?: Maybe<Scalars['String']>,
+  readonly taxid?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceMolecule = {
+  readonly __typename?: 'PdbxReferenceMolecule',
+  readonly chem_comp_id?: Maybe<Scalars['String']>,
+  readonly class?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly class_evidence_code?: Maybe<Scalars['String']>,
+  readonly compound_details?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly formula?: Maybe<Scalars['String']>,
+  readonly formula_weight?: Maybe<Scalars['Float']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly prd_id: Scalars['String'],
+  readonly release_status?: Maybe<Scalars['String']>,
+  readonly replaced_by?: Maybe<Scalars['String']>,
+  readonly replaces?: Maybe<Scalars['String']>,
+  readonly represent_as?: Maybe<Scalars['String']>,
+  readonly representative_PDB_id_code?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly type_evidence_code?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceMoleculeAnnotation = {
+  readonly __typename?: 'PdbxReferenceMoleculeAnnotation',
+  readonly family_prd_id: Scalars['String'],
+  readonly ordinal: Scalars['Int'],
+  readonly prd_id?: Maybe<Scalars['String']>,
+  readonly source?: Maybe<Scalars['String']>,
+  readonly text?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceMoleculeDetails = {
+  readonly __typename?: 'PdbxReferenceMoleculeDetails',
+  readonly family_prd_id: Scalars['String'],
+  readonly ordinal: Scalars['Int'],
+  readonly source?: Maybe<Scalars['String']>,
+  readonly source_id?: Maybe<Scalars['String']>,
+  readonly text?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceMoleculeFamily = {
+  readonly __typename?: 'PdbxReferenceMoleculeFamily',
+  readonly family_prd_id: Scalars['String'],
+  readonly name?: Maybe<Scalars['String']>,
+  readonly release_status?: Maybe<Scalars['String']>,
+  readonly replaced_by?: Maybe<Scalars['String']>,
+  readonly replaces?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceMoleculeFeatures = {
+  readonly __typename?: 'PdbxReferenceMoleculeFeatures',
+  readonly family_prd_id: Scalars['String'],
+  readonly ordinal: Scalars['Int'],
+  readonly prd_id: Scalars['String'],
+  readonly source?: Maybe<Scalars['String']>,
+  readonly source_ordinal?: Maybe<Scalars['Int']>,
+  readonly type?: Maybe<Scalars['String']>,
+  readonly value?: Maybe<Scalars['String']>,
+};
+
+export type PdbxReferenceMoleculeList = {
+  readonly __typename?: 'PdbxReferenceMoleculeList',
+  readonly family_prd_id: Scalars['String'],
+  readonly prd_id: Scalars['String'],
+};
+
+export type PdbxReferenceMoleculeRelatedStructures = {
+  readonly __typename?: 'PdbxReferenceMoleculeRelatedStructures',
+  readonly citation_id?: Maybe<Scalars['String']>,
+  readonly db_accession?: Maybe<Scalars['String']>,
+  readonly db_code?: Maybe<Scalars['String']>,
+  readonly db_name?: Maybe<Scalars['String']>,
+  readonly family_prd_id: Scalars['String'],
+  readonly formula?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+};
+
+export type PdbxReferenceMoleculeSynonyms = {
+  readonly __typename?: 'PdbxReferenceMoleculeSynonyms',
+  readonly family_prd_id: Scalars['String'],
+  readonly name?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly prd_id: Scalars['String'],
+  readonly source?: Maybe<Scalars['String']>,
+};
+
+export type PdbxSerialCrystallographyDataReduction = {
+  readonly __typename?: 'PdbxSerialCrystallographyDataReduction',
+  readonly crystal_hits?: Maybe<Scalars['Int']>,
+  readonly diffrn_id: Scalars['String'],
+  readonly droplet_hits?: Maybe<Scalars['Int']>,
+  readonly frame_hits?: Maybe<Scalars['Int']>,
+  readonly frames_failed_index?: Maybe<Scalars['Int']>,
+  readonly frames_indexed?: Maybe<Scalars['Int']>,
+  readonly frames_total?: Maybe<Scalars['Int']>,
+  readonly lattices_indexed?: Maybe<Scalars['Int']>,
+  readonly xfel_pulse_events?: Maybe<Scalars['Int']>,
+  readonly xfel_run_numbers?: Maybe<Scalars['String']>,
+};
+
+export type PdbxSerialCrystallographyMeasurement = {
+  readonly __typename?: 'PdbxSerialCrystallographyMeasurement',
+  readonly collection_time_total?: Maybe<Scalars['Float']>,
+  readonly collimation?: Maybe<Scalars['String']>,
+  readonly diffrn_id: Scalars['String'],
+  readonly focal_spot_size?: Maybe<Scalars['Float']>,
+  readonly photons_per_pulse?: Maybe<Scalars['Float']>,
+  readonly pulse_duration?: Maybe<Scalars['Float']>,
+  readonly pulse_energy?: Maybe<Scalars['Float']>,
+  readonly pulse_photon_energy?: Maybe<Scalars['Float']>,
+  readonly source_distance?: Maybe<Scalars['Float']>,
+  readonly source_size?: Maybe<Scalars['Float']>,
+  readonly xfel_pulse_repetition_rate?: Maybe<Scalars['Float']>,
+};
+
+export type PdbxSerialCrystallographySampleDelivery = {
+  readonly __typename?: 'PdbxSerialCrystallographySampleDelivery',
+  readonly description?: Maybe<Scalars['String']>,
+  readonly diffrn_id: Scalars['String'],
+  readonly method?: Maybe<Scalars['String']>,
+};
+
+export type PdbxSerialCrystallographySampleDeliveryFixedTarget = {
+  readonly __typename?: 'PdbxSerialCrystallographySampleDeliveryFixedTarget',
+  readonly crystals_per_unit?: Maybe<Scalars['Int']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly diffrn_id: Scalars['String'],
+  readonly motion_control?: Maybe<Scalars['String']>,
+  readonly sample_dehydration_prevention?: Maybe<Scalars['String']>,
+  readonly sample_holding?: Maybe<Scalars['String']>,
+  readonly sample_solvent?: Maybe<Scalars['String']>,
+  readonly sample_unit_size?: Maybe<Scalars['Float']>,
+  readonly support_base?: Maybe<Scalars['String']>,
+  readonly velocity_horizontal?: Maybe<Scalars['Float']>,
+  readonly velocity_vertical?: Maybe<Scalars['Float']>,
+};
+
+export type PdbxSerialCrystallographySampleDeliveryInjection = {
+  readonly __typename?: 'PdbxSerialCrystallographySampleDeliveryInjection',
+  readonly carrier_solvent?: Maybe<Scalars['String']>,
+  readonly crystal_concentration?: Maybe<Scalars['Float']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly diffrn_id: Scalars['String'],
+  readonly filter_size?: Maybe<Scalars['Float']>,
+  readonly flow_rate?: Maybe<Scalars['Float']>,
+  readonly injector_diameter?: Maybe<Scalars['Float']>,
+  readonly injector_nozzle?: Maybe<Scalars['String']>,
+  readonly injector_pressure?: Maybe<Scalars['Float']>,
+  readonly injector_temperature?: Maybe<Scalars['Float']>,
+  readonly jet_diameter?: Maybe<Scalars['Float']>,
+  readonly power_by?: Maybe<Scalars['String']>,
+  readonly preparation?: Maybe<Scalars['String']>,
+};
+
+export type PdbxSgProject = {
+  readonly __typename?: 'PdbxSGProject',
+  readonly full_name_of_center?: Maybe<Scalars['String']>,
+  readonly id: Scalars['Int'],
+  readonly initial_of_center?: Maybe<Scalars['String']>,
+  readonly project_name?: Maybe<Scalars['String']>,
+};
+
+export type PdbxSolnScatter = {
+  readonly __typename?: 'PdbxSolnScatter',
+  readonly buffer_name?: Maybe<Scalars['String']>,
+  readonly concentration_range?: Maybe<Scalars['String']>,
+  readonly data_analysis_software_list?: Maybe<Scalars['String']>,
+  readonly data_reduction_software_list?: Maybe<Scalars['String']>,
+  readonly detector_specific?: Maybe<Scalars['String']>,
+  readonly detector_type?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly max_mean_cross_sectional_radii_gyration?: Maybe<Scalars['Float']>,
+  readonly max_mean_cross_sectional_radii_gyration_esd?: Maybe<Scalars['Float']>,
+  readonly mean_guiner_radius?: Maybe<Scalars['Float']>,
+  readonly mean_guiner_radius_esd?: Maybe<Scalars['Float']>,
+  readonly min_mean_cross_sectional_radii_gyration?: Maybe<Scalars['Float']>,
+  readonly min_mean_cross_sectional_radii_gyration_esd?: Maybe<Scalars['Float']>,
+  readonly num_time_frames?: Maybe<Scalars['Int']>,
+  readonly protein_length?: Maybe<Scalars['String']>,
+  readonly sample_pH?: Maybe<Scalars['Float']>,
+  readonly source_beamline?: Maybe<Scalars['String']>,
+  readonly source_beamline_instrument?: Maybe<Scalars['String']>,
+  readonly source_class?: Maybe<Scalars['String']>,
+  readonly source_type?: Maybe<Scalars['String']>,
+  readonly temperature?: Maybe<Scalars['Float']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type PdbxSolnScatterModel = {
+  readonly __typename?: 'PdbxSolnScatterModel',
+  readonly conformer_selection_criteria?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly entry_fitting_list?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly method?: Maybe<Scalars['String']>,
+  readonly num_conformers_calculated?: Maybe<Scalars['Int']>,
+  readonly num_conformers_submitted?: Maybe<Scalars['Int']>,
+  readonly representative_conformer?: Maybe<Scalars['Int']>,
+  readonly scatter_id: Scalars['String'],
+  readonly software_author_list?: Maybe<Scalars['String']>,
+  readonly software_list?: Maybe<Scalars['String']>,
+};
+
+export type PdbxStructAssembly = {
+  readonly __typename?: 'PdbxStructAssembly',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+  readonly method_details?: Maybe<Scalars['String']>,
+  readonly oligomeric_count?: Maybe<Scalars['Int']>,
+  readonly oligomeric_details?: Maybe<Scalars['String']>,
+  readonly rcsb_candidate_assembly?: Maybe<Scalars['String']>,
+  readonly rcsb_details?: Maybe<Scalars['String']>,
+};
+
+export type PdbxStructAssemblyAuthEvidence = {
+  readonly __typename?: 'PdbxStructAssemblyAuthEvidence',
+  readonly assembly_id: Scalars['String'],
+  readonly details?: Maybe<Scalars['String']>,
+  readonly experimental_support?: Maybe<Scalars['String']>,
+  readonly id: Scalars['String'],
+};
+
+export type PdbxStructAssemblyGen = {
+  readonly __typename?: 'PdbxStructAssemblyGen',
+  readonly assembly_id?: Maybe<Scalars['String']>,
+  readonly asym_id_list?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly oper_expression?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+};
+
+export type PdbxStructAssemblyProp = {
+  readonly __typename?: 'PdbxStructAssemblyProp',
+  readonly biol_id: Scalars['String'],
+  readonly type: Scalars['String'],
+  readonly value?: Maybe<Scalars['String']>,
+};
+
+export type PdbxStructOperList = {
+  readonly __typename?: 'PdbxStructOperList',
+  readonly id: Scalars['String'],
+  readonly matrix_1_1?: Maybe<Scalars['Float']>,
+  readonly matrix_1_2?: Maybe<Scalars['Float']>,
+  readonly matrix_1_3?: Maybe<Scalars['Float']>,
+  readonly matrix_2_1?: Maybe<Scalars['Float']>,
+  readonly matrix_2_2?: Maybe<Scalars['Float']>,
+  readonly matrix_2_3?: Maybe<Scalars['Float']>,
+  readonly matrix_3_1?: Maybe<Scalars['Float']>,
+  readonly matrix_3_2?: Maybe<Scalars['Float']>,
+  readonly matrix_3_3?: Maybe<Scalars['Float']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly symmetry_operation?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+  readonly vector_1?: Maybe<Scalars['Float']>,
+  readonly vector_2?: Maybe<Scalars['Float']>,
+  readonly vector_3?: Maybe<Scalars['Float']>,
+};
+
+export type PdbxStructSpecialSymmetry = {
+  readonly __typename?: 'PdbxStructSpecialSymmetry',
+  readonly PDB_model_num?: Maybe<Scalars['Int']>,
+  readonly auth_seq_id?: Maybe<Scalars['String']>,
+  readonly id: Scalars['Int'],
+  readonly label_asym_id?: Maybe<Scalars['String']>,
+  readonly label_comp_id?: Maybe<Scalars['String']>,
+};
+
+export type PdbxVrptSummary = {
+  readonly __typename?: 'PdbxVrptSummary',
+  readonly B_factor_type?: Maybe<Scalars['String']>,
+  readonly Babinet_b?: Maybe<Scalars['Float']>,
+  readonly Babinet_k?: Maybe<Scalars['Float']>,
+  readonly CA_ONLY?: Maybe<Scalars['String']>,
+  readonly DCC_R?: Maybe<Scalars['Float']>,
+  readonly DCC_Rfree?: Maybe<Scalars['Float']>,
+  readonly DCC_refinement_program?: Maybe<Scalars['String']>,
+  readonly EDS_R?: Maybe<Scalars['Float']>,
+  readonly EDS_resolution?: Maybe<Scalars['Float']>,
+  readonly EDS_resolution_low?: Maybe<Scalars['Float']>,
+  readonly Fo_Fc_correlation?: Maybe<Scalars['Float']>,
+  readonly I_over_sigma?: Maybe<Scalars['String']>,
+  readonly PDB_R?: Maybe<Scalars['Float']>,
+  readonly PDB_Rfree?: Maybe<Scalars['Float']>,
+  readonly PDB_deposition_date?: Maybe<Scalars['Date']>,
+  readonly PDB_resolution?: Maybe<Scalars['Float']>,
+  readonly PDB_resolution_low?: Maybe<Scalars['Float']>,
+  readonly PDB_revision_date?: Maybe<Scalars['Date']>,
+  readonly PDB_revision_number?: Maybe<Scalars['Float']>,
+  readonly RNA_suiteness?: Maybe<Scalars['Float']>,
+  readonly Wilson_B_aniso?: Maybe<Scalars['String']>,
+  readonly Wilson_B_estimate?: Maybe<Scalars['Float']>,
+  readonly absolute_percentile_DCC_Rfree?: Maybe<Scalars['Float']>,
+  readonly absolute_percentile_RNA_suiteness?: Maybe<Scalars['Float']>,
+  readonly absolute_percentile_clashscore?: Maybe<Scalars['Float']>,
+  readonly absolute_percentile_percent_RSRZ_outliers?: Maybe<Scalars['Float']>,
+  readonly absolute_percentile_percent_ramachandran_outliers?: Maybe<Scalars['Float']>,
+  readonly absolute_percentile_percent_rotamer_outliers?: Maybe<Scalars['Float']>,
+  readonly acentric_outliers?: Maybe<Scalars['Int']>,
+  readonly angles_RMSZ?: Maybe<Scalars['Float']>,
+  readonly attempted_validation_steps?: Maybe<Scalars['String']>,
+  readonly bonds_RMSZ?: Maybe<Scalars['Float']>,
+  readonly bulk_solvent_b?: Maybe<Scalars['Float']>,
+  readonly bulk_solvent_k?: Maybe<Scalars['Float']>,
+  readonly ccp4version?: Maybe<Scalars['String']>,
+  readonly centric_outliers?: Maybe<Scalars['Float']>,
+  readonly chemical_shift_completeness?: Maybe<Scalars['Float']>,
+  readonly chemical_shift_completeness_full_length?: Maybe<Scalars['Float']>,
+  readonly chemical_shifts_input_filename?: Maybe<Scalars['String']>,
+  readonly clashscore?: Maybe<Scalars['Float']>,
+  readonly clashscore_full_length?: Maybe<Scalars['Float']>,
+  readonly coordinates_input_filename?: Maybe<Scalars['String']>,
+  readonly cyrange_error?: Maybe<Scalars['String']>,
+  readonly cyrange_number_of_domains?: Maybe<Scalars['Int']>,
+  readonly cyrange_version?: Maybe<Scalars['String']>,
+  readonly data_anisotropy?: Maybe<Scalars['Float']>,
+  readonly data_completeness?: Maybe<Scalars['Float']>,
+  readonly high_resol_relative_percentile_DCC_Rfree?: Maybe<Scalars['Float']>,
+  readonly high_resol_relative_percentile_RNA_suiteness?: Maybe<Scalars['Float']>,
+  readonly high_resol_relative_percentile_clashscore?: Maybe<Scalars['Float']>,
+  readonly high_resol_relative_percentile_percent_RSRZ_outliers?: Maybe<Scalars['Float']>,
+  readonly high_resol_relative_percentile_percent_ramachandran_outliers?: Maybe<Scalars['Float']>,
+  readonly high_resol_relative_percentile_percent_rotamer_outliers?: Maybe<Scalars['Float']>,
+  readonly ligands_for_buster_report?: Maybe<Scalars['String']>,
+  readonly low_resol_relative_percentile_DCC_Rfree?: Maybe<Scalars['Float']>,
+  readonly low_resol_relative_percentile_RNA_suiteness?: Maybe<Scalars['Float']>,
+  readonly low_resol_relative_percentile_clashscore?: Maybe<Scalars['Float']>,
+  readonly low_resol_relative_percentile_percent_RSRZ_outliers?: Maybe<Scalars['Float']>,
+  readonly low_resol_relative_percentile_percent_ramachandran_outliers?: Maybe<Scalars['Float']>,
+  readonly low_resol_relative_percentile_percent_rotamer_outliers?: Maybe<Scalars['Float']>,
+  readonly medoid_model?: Maybe<Scalars['Int']>,
+  readonly nmr_models_consistency_flag?: Maybe<Scalars['String']>,
+  readonly nmrclust_error?: Maybe<Scalars['String']>,
+  readonly nmrclust_number_of_clusters?: Maybe<Scalars['Int']>,
+  readonly nmrclust_number_of_models?: Maybe<Scalars['Int']>,
+  readonly nmrclust_number_of_outliers?: Maybe<Scalars['Int']>,
+  readonly nmrclust_representative_model?: Maybe<Scalars['Int']>,
+  readonly nmrclust_version?: Maybe<Scalars['String']>,
+  readonly no_ligands_for_buster_report?: Maybe<Scalars['String']>,
+  readonly no_ligands_for_mogul?: Maybe<Scalars['String']>,
+  readonly no_percentile_property?: Maybe<Scalars['String']>,
+  readonly num_H_reduce?: Maybe<Scalars['Float']>,
+  readonly num_PDBids_absolute_percentile_DCC_Rfree?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_absolute_percentile_RNA_suiteness?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_absolute_percentile_clashscore?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_absolute_percentile_percent_RSRZ_outliers?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_absolute_percentile_percent_ramachandran_outliers?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_absolute_percentile_percent_rotamer_outliers?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_relative_percentile_DCC_Rfree?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_relative_percentile_RNA_suiteness?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_relative_percentile_clashscore?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_relative_percentile_percent_RSRZ_outliers?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_relative_percentile_percent_ramachandran_outliers?: Maybe<Scalars['Int']>,
+  readonly num_PDBids_relative_percentile_percent_rotamer_outliers?: Maybe<Scalars['Int']>,
+  readonly num_angles_RMSZ?: Maybe<Scalars['Int']>,
+  readonly num_bonds_RMSZ?: Maybe<Scalars['Int']>,
+  readonly num_free_reflections?: Maybe<Scalars['Int']>,
+  readonly num_miller_indices?: Maybe<Scalars['Int']>,
+  readonly panav_version?: Maybe<Scalars['String']>,
+  readonly percent_RSRZ_outliers?: Maybe<Scalars['Float']>,
+  readonly percent_free_reflections?: Maybe<Scalars['Float']>,
+  readonly percent_ramachandran_outliers?: Maybe<Scalars['Float']>,
+  readonly percent_ramachandran_outliers_full_length?: Maybe<Scalars['Float']>,
+  readonly percent_rotamer_outliers?: Maybe<Scalars['Float']>,
+  readonly percent_rotamer_outliers_full_length?: Maybe<Scalars['Float']>,
+  readonly percentilebins?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly protein_DNA_RNA_entities?: Maybe<Scalars['String']>,
+  readonly rci_version?: Maybe<Scalars['String']>,
+  readonly reflections_input_filename?: Maybe<Scalars['String']>,
+  readonly refmac_version?: Maybe<Scalars['String']>,
+  readonly relative_percentile_DCC_Rfree?: Maybe<Scalars['Float']>,
+  readonly relative_percentile_RNA_suiteness?: Maybe<Scalars['Float']>,
+  readonly relative_percentile_clashscore?: Maybe<Scalars['Float']>,
+  readonly relative_percentile_percent_RSRZ_outliers?: Maybe<Scalars['Float']>,
+  readonly relative_percentile_percent_ramachandran_outliers?: Maybe<Scalars['Float']>,
+  readonly relative_percentile_percent_rotamer_outliers?: Maybe<Scalars['Float']>,
+  readonly report_creation_date?: Maybe<Scalars['String']>,
+  readonly resol_high_from_reflectionsfile?: Maybe<Scalars['Float']>,
+  readonly resol_low_from_reflectionsfile?: Maybe<Scalars['Float']>,
+  readonly restypes_notchecked_for_bond_angle_geometry?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly shiftchecker_version?: Maybe<Scalars['String']>,
+  readonly trans_NSC?: Maybe<Scalars['String']>,
+  readonly twin_L?: Maybe<Scalars['Float']>,
+  readonly twin_L2?: Maybe<Scalars['Float']>,
+  readonly twin_fraction?: Maybe<Scalars['String']>,
+  readonly xtriage_input_columns?: Maybe<Scalars['String']>,
+};
+
+export type Query = {
+  readonly __typename?: 'Query',
+  readonly polymer_entity_instance?: Maybe<CorePolymerEntityInstance>,
+  readonly nonpolymer_entities?: Maybe<ReadonlyArray<Maybe<CoreNonpolymerEntity>>>,
+  readonly polymer_entities?: Maybe<ReadonlyArray<Maybe<CorePolymerEntity>>>,
+  readonly polymer_entity?: Maybe<CorePolymerEntity>,
+  readonly pubmed?: Maybe<CorePubmed>,
+  readonly pfam?: Maybe<CorePfam>,
+  readonly assembly?: Maybe<CoreAssembly>,
+  readonly polymer_entity_instances?: Maybe<ReadonlyArray<Maybe<CorePolymerEntityInstance>>>,
+  readonly assemblies?: Maybe<ReadonlyArray<Maybe<CoreAssembly>>>,
+  readonly go?: Maybe<CoreGo>,
+  readonly nonpolymer_entity_instance?: Maybe<CoreNonpolymerEntityInstance>,
+  readonly chem_comp?: Maybe<CoreChemComp>,
+  readonly entry?: Maybe<CoreEntry>,
+  readonly entries?: Maybe<ReadonlyArray<Maybe<CoreEntry>>>,
+  readonly uniprot?: Maybe<CoreUniprot>,
+  readonly nonpolymer_entity_instances?: Maybe<ReadonlyArray<Maybe<CoreNonpolymerEntityInstance>>>,
+  readonly nonpolymer_entity?: Maybe<CoreNonpolymerEntity>,
+};
+
+
+export type QueryPolymer_Entity_InstanceArgs = {
+  asym_id: Scalars['String'],
+  entry_id: Scalars['String']
+};
+
+
+export type QueryNonpolymer_EntitiesArgs = {
+  entity_ids: ReadonlyArray<Scalars['String']>
+};
+
+
+export type QueryPolymer_EntitiesArgs = {
+  entity_ids: ReadonlyArray<Scalars['String']>
+};
+
+
+export type QueryPolymer_EntityArgs = {
+  entity_id: Scalars['String'],
+  entry_id: Scalars['String']
+};
+
+
+export type QueryPubmedArgs = {
+  pubmed_id: Scalars['Int']
+};
+
+
+export type QueryPfamArgs = {
+  pfam_id: Scalars['String']
+};
+
+
+export type QueryAssemblyArgs = {
+  assembly_id: Scalars['String'],
+  entry_id: Scalars['String']
+};
+
+
+export type QueryPolymer_Entity_InstancesArgs = {
+  instance_ids: ReadonlyArray<Maybe<Scalars['String']>>
+};
+
+
+export type QueryAssembliesArgs = {
+  assembly_ids: ReadonlyArray<Maybe<Scalars['String']>>
+};
+
+
+export type QueryGoArgs = {
+  go_id: Scalars['String']
+};
+
+
+export type QueryNonpolymer_Entity_InstanceArgs = {
+  asym_id: Scalars['String'],
+  entry_id: Scalars['String']
+};
+
+
+export type QueryChem_CompArgs = {
+  comp_id: Scalars['String']
+};
+
+
+export type QueryEntryArgs = {
+  entry_id: Scalars['String']
+};
+
+
+export type QueryEntriesArgs = {
+  entry_ids: ReadonlyArray<Scalars['String']>
+};
+
+
+export type QueryUniprotArgs = {
+  uniprot_id: Scalars['String']
+};
+
+
+export type QueryNonpolymer_Entity_InstancesArgs = {
+  instance_ids: ReadonlyArray<Maybe<Scalars['String']>>
+};
+
+
+export type QueryNonpolymer_EntityArgs = {
+  entity_id: Scalars['String'],
+  entry_id: Scalars['String']
+};
+
+export type RcsbAccessionInfo = {
+  readonly __typename?: 'RcsbAccessionInfo',
+  readonly deposit_date?: Maybe<Scalars['Date']>,
+  readonly initial_release_date?: Maybe<Scalars['Date']>,
+  readonly major_revision?: Maybe<Scalars['Int']>,
+  readonly minor_revision?: Maybe<Scalars['Int']>,
+  readonly revision_date?: Maybe<Scalars['Date']>,
+  readonly status_code?: Maybe<Scalars['String']>,
+};
+
+export type RcsbAssemblyContainerIdentifiers = {
+  readonly __typename?: 'RcsbAssemblyContainerIdentifiers',
+  readonly assembly_id: Scalars['String'],
+  readonly entry_id: Scalars['String'],
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+};
+
+export type RcsbAssemblyInfo = {
+  readonly __typename?: 'RcsbAssemblyInfo',
+  readonly assembly_id?: Maybe<Scalars['String']>,
+  readonly atom_count?: Maybe<Scalars['Int']>,
+  readonly branched_atom_count?: Maybe<Scalars['Int']>,
+  readonly branched_entity_count?: Maybe<Scalars['Int']>,
+  readonly branched_entity_instance_count?: Maybe<Scalars['Int']>,
+  readonly entry_id: Scalars['String'],
+  readonly modeled_polymer_monomer_count?: Maybe<Scalars['Int']>,
+  readonly na_polymer_entity_types?: Maybe<Scalars['String']>,
+  readonly nonpolymer_atom_count?: Maybe<Scalars['Int']>,
+  readonly nonpolymer_entity_count?: Maybe<Scalars['Int']>,
+  readonly nonpolymer_entity_instance_count?: Maybe<Scalars['Int']>,
+  readonly polymer_atom_count?: Maybe<Scalars['Int']>,
+  readonly polymer_composition?: Maybe<Scalars['String']>,
+  readonly polymer_entity_count?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_DNA?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_RNA?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_nucleic_acid?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_nucleic_acid_hybrid?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_protein?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_instance_count?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_instance_count_DNA?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_instance_count_RNA?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_instance_count_nucleic_acid?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_instance_count_nucleic_acid_hybrid?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_instance_count_protein?: Maybe<Scalars['Int']>,
+  readonly polymer_monomer_count?: Maybe<Scalars['Int']>,
+  readonly selected_polymer_entity_types?: Maybe<Scalars['String']>,
+  readonly solvent_atom_count?: Maybe<Scalars['Int']>,
+  readonly solvent_entity_count?: Maybe<Scalars['Int']>,
+  readonly solvent_entity_instance_count?: Maybe<Scalars['Int']>,
+  readonly unmodeled_polymer_monomer_count?: Maybe<Scalars['Int']>,
+};
+
+export type RcsbBindingAffinity = {
+  readonly __typename?: 'RcsbBindingAffinity',
+  readonly comp_id: Scalars['String'],
+  readonly display_order: Scalars['Int'],
+  readonly display_value: Scalars['String'],
+  readonly link: Scalars['String'],
+  readonly provenance_code: Scalars['String'],
+  readonly reference_sequence_identity?: Maybe<Scalars['Int']>,
+  readonly symbol?: Maybe<Scalars['String']>,
+  readonly type: Scalars['String'],
+  readonly unit: Scalars['String'],
+  readonly value: Scalars['Float'],
+};
+
+export type RcsbBirdCitation = {
+  readonly __typename?: 'RcsbBirdCitation',
+  readonly id: Scalars['String'],
+  readonly journal_abbrev?: Maybe<Scalars['String']>,
+  readonly journal_volume?: Maybe<Scalars['String']>,
+  readonly page_first?: Maybe<Scalars['String']>,
+  readonly page_last?: Maybe<Scalars['String']>,
+  readonly pdbx_database_id_DOI?: Maybe<Scalars['String']>,
+  readonly pdbx_database_id_PubMed?: Maybe<Scalars['Int']>,
+  readonly rcsb_authors?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly title?: Maybe<Scalars['String']>,
+  readonly year?: Maybe<Scalars['Int']>,
+};
+
+export type RcsbChemCompContainerIdentifiers = {
+  readonly __typename?: 'RcsbChemCompContainerIdentifiers',
+  readonly atc_codes?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly comp_id: Scalars['String'],
+  readonly drugbank_id?: Maybe<Scalars['String']>,
+  readonly prd_id?: Maybe<Scalars['String']>,
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+  readonly subcomponent_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+};
+
+export type RcsbChemCompDescriptor = {
+  readonly __typename?: 'RcsbChemCompDescriptor',
+  readonly InChI?: Maybe<Scalars['String']>,
+  readonly InChIKey?: Maybe<Scalars['String']>,
+  readonly SMILES?: Maybe<Scalars['String']>,
+  readonly SMILES_stereo?: Maybe<Scalars['String']>,
+  readonly comp_id: Scalars['String'],
+};
+
+export type RcsbChemCompInfo = {
+  readonly __typename?: 'RcsbChemCompInfo',
+  readonly atom_count?: Maybe<Scalars['Int']>,
+  readonly atom_count_chiral?: Maybe<Scalars['Int']>,
+  readonly atom_count_heavy?: Maybe<Scalars['Int']>,
+  readonly bond_count?: Maybe<Scalars['Int']>,
+  readonly bond_count_aromatic?: Maybe<Scalars['Int']>,
+  readonly comp_id: Scalars['String'],
+  readonly initial_release_date?: Maybe<Scalars['Date']>,
+  readonly release_status?: Maybe<Scalars['String']>,
+  readonly revision_date?: Maybe<Scalars['Date']>,
+};
+
+export type RcsbChemCompRelated = {
+  readonly __typename?: 'RcsbChemCompRelated',
+  readonly comp_id: Scalars['String'],
+  readonly ordinal: Scalars['Int'],
+  readonly related_mapping_method?: Maybe<Scalars['String']>,
+  readonly resource_accession_code?: Maybe<Scalars['String']>,
+  readonly resource_lineage?: Maybe<ReadonlyArray<Maybe<RcsbChemCompRelatedResourceLineage>>>,
+  readonly resource_name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbChemCompRelatedResourceLineage = {
+  readonly __typename?: 'RcsbChemCompRelatedResourceLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbChemCompSynonyms = {
+  readonly __typename?: 'RcsbChemCompSynonyms',
+  readonly comp_id: Scalars['String'],
+  readonly name?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly provenance_source?: Maybe<Scalars['String']>,
+};
+
+export type RcsbChemCompTarget = {
+  readonly __typename?: 'RcsbChemCompTarget',
+  readonly comp_id: Scalars['String'],
+  readonly interaction_type?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly provenance_source?: Maybe<Scalars['String']>,
+  readonly reference_database_accession_code?: Maybe<Scalars['String']>,
+  readonly reference_database_name?: Maybe<Scalars['String']>,
+  readonly target_actions?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+};
+
+export type RcsbClusterFlexibility = {
+  readonly __typename?: 'RcsbClusterFlexibility',
+  readonly avg_rmsd?: Maybe<Scalars['Float']>,
+  readonly label?: Maybe<Scalars['String']>,
+  readonly link?: Maybe<Scalars['String']>,
+  readonly max_rmsd?: Maybe<Scalars['Float']>,
+  readonly provenance_code?: Maybe<Scalars['String']>,
+};
+
+export type RcsbClusterMembership = {
+  readonly __typename?: 'RcsbClusterMembership',
+  readonly cluster_id?: Maybe<Scalars['Int']>,
+  readonly identity?: Maybe<Scalars['Int']>,
+};
+
+export type RcsbEntityHostOrganism = {
+  readonly __typename?: 'RcsbEntityHostOrganism',
+  readonly beg_seq_num?: Maybe<Scalars['Int']>,
+  readonly common_name?: Maybe<Scalars['String']>,
+  readonly end_seq_num?: Maybe<Scalars['Int']>,
+  readonly ncbi_common_names?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly ncbi_parent_scientific_name?: Maybe<Scalars['String']>,
+  readonly ncbi_scientific_name?: Maybe<Scalars['String']>,
+  readonly ncbi_taxonomy_id?: Maybe<Scalars['Int']>,
+  readonly pdbx_src_id: Scalars['String'],
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly scientific_name?: Maybe<Scalars['String']>,
+  readonly taxonomy_lineage?: Maybe<ReadonlyArray<Maybe<RcsbEntityHostOrganismTaxonomyLineage>>>,
+};
+
+export type RcsbEntityHostOrganismTaxonomyLineage = {
+  readonly __typename?: 'RcsbEntityHostOrganismTaxonomyLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbEntitySourceOrganism = {
+  readonly __typename?: 'RcsbEntitySourceOrganism',
+  readonly beg_seq_num?: Maybe<Scalars['Int']>,
+  readonly common_name?: Maybe<Scalars['String']>,
+  readonly end_seq_num?: Maybe<Scalars['Int']>,
+  readonly ncbi_common_names?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly ncbi_parent_scientific_name?: Maybe<Scalars['String']>,
+  readonly ncbi_scientific_name?: Maybe<Scalars['String']>,
+  readonly ncbi_taxonomy_id?: Maybe<Scalars['Int']>,
+  readonly pdbx_src_id: Scalars['String'],
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly rcsb_gene_name?: Maybe<ReadonlyArray<Maybe<RcsbEntitySourceOrganismRcsbGeneName>>>,
+  readonly scientific_name?: Maybe<Scalars['String']>,
+  readonly source_type?: Maybe<Scalars['String']>,
+  readonly taxonomy_lineage?: Maybe<ReadonlyArray<Maybe<RcsbEntitySourceOrganismTaxonomyLineage>>>,
+};
+
+export type RcsbEntitySourceOrganismRcsbGeneName = {
+  readonly __typename?: 'RcsbEntitySourceOrganismRcsbGeneName',
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly value?: Maybe<Scalars['String']>,
+};
+
+export type RcsbEntitySourceOrganismTaxonomyLineage = {
+  readonly __typename?: 'RcsbEntitySourceOrganismTaxonomyLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbEntryContainerIdentifiers = {
+  readonly __typename?: 'RcsbEntryContainerIdentifiers',
+  readonly assembly_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly branched_entity_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly emdb_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly entity_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly entry_id: Scalars['String'],
+  readonly non_polymer_entity_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly polymer_entity_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly pubmed_id?: Maybe<Scalars['Int']>,
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+  readonly related_emdb_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly water_entity_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+};
+
+export type RcsbEntryInfo = {
+  readonly __typename?: 'RcsbEntryInfo',
+  readonly assembly_count?: Maybe<Scalars['Int']>,
+  readonly branched_entity_count?: Maybe<Scalars['Int']>,
+  readonly branched_molecular_weight_maximum?: Maybe<Scalars['Float']>,
+  readonly branched_molecular_weight_minimum?: Maybe<Scalars['Float']>,
+  readonly cis_peptide_count?: Maybe<Scalars['Int']>,
+  readonly deposited_atom_count?: Maybe<Scalars['Int']>,
+  readonly deposited_model_count?: Maybe<Scalars['Int']>,
+  readonly deposited_modeled_polymer_monomer_count?: Maybe<Scalars['Int']>,
+  readonly deposited_nonpolymer_entity_instance_count?: Maybe<Scalars['Int']>,
+  readonly deposited_polymer_entity_instance_count?: Maybe<Scalars['Int']>,
+  readonly deposited_polymer_monomer_count?: Maybe<Scalars['Int']>,
+  readonly deposited_unmodeled_polymer_monomer_count?: Maybe<Scalars['Int']>,
+  readonly disulfide_bond_count?: Maybe<Scalars['Int']>,
+  readonly entity_count?: Maybe<Scalars['Int']>,
+  readonly experimental_method?: Maybe<Scalars['String']>,
+  readonly experimental_method_count?: Maybe<Scalars['Int']>,
+  readonly inter_mol_covalent_bond_count?: Maybe<Scalars['Int']>,
+  readonly inter_mol_metalic_bond_count?: Maybe<Scalars['Int']>,
+  readonly molecular_weight?: Maybe<Scalars['Float']>,
+  readonly na_polymer_entity_types?: Maybe<Scalars['String']>,
+  readonly nonpolymer_bound_components?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly nonpolymer_entity_count?: Maybe<Scalars['Int']>,
+  readonly nonpolymer_molecular_weight_maximum?: Maybe<Scalars['Float']>,
+  readonly nonpolymer_molecular_weight_minimum?: Maybe<Scalars['Float']>,
+  readonly polymer_composition?: Maybe<Scalars['String']>,
+  readonly polymer_entity_count?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_DNA?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_RNA?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_nucleic_acid?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_nucleic_acid_hybrid?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_count_protein?: Maybe<Scalars['Int']>,
+  readonly polymer_entity_taxonomy_count?: Maybe<Scalars['Int']>,
+  readonly polymer_molecular_weight_maximum?: Maybe<Scalars['Float']>,
+  readonly polymer_molecular_weight_minimum?: Maybe<Scalars['Float']>,
+  readonly polymer_monomer_count_maximum?: Maybe<Scalars['Int']>,
+  readonly polymer_monomer_count_minimum?: Maybe<Scalars['Int']>,
+  readonly resolution_combined?: Maybe<ReadonlyArray<Maybe<Scalars['Float']>>>,
+  readonly selected_polymer_entity_types?: Maybe<Scalars['String']>,
+  readonly software_programs_combined?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly solvent_entity_count?: Maybe<Scalars['Int']>,
+};
+
+export type RcsbExternalReferences = {
+  readonly __typename?: 'RcsbExternalReferences',
+  readonly id: Scalars['String'],
+  readonly link: Scalars['String'],
+  readonly type: Scalars['String'],
+};
+
+export type RcsbGenomicLineage = {
+  readonly __typename?: 'RcsbGenomicLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbGoContainerIdentifiers = {
+  readonly __typename?: 'RcsbGoContainerIdentifiers',
+  readonly go_id?: Maybe<Scalars['String']>,
+};
+
+export type RcsbLatestRevision = {
+  readonly __typename?: 'RcsbLatestRevision',
+  readonly major_revision?: Maybe<Scalars['Int']>,
+  readonly minor_revision?: Maybe<Scalars['Int']>,
+  readonly revision_date?: Maybe<Scalars['Date']>,
+};
+
+export type RcsbMembraneLineage = {
+  readonly __typename?: 'RcsbMembraneLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerEntity = {
+  readonly __typename?: 'RcsbNonpolymerEntity',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly formula_weight?: Maybe<Scalars['Float']>,
+  readonly pdbx_description?: Maybe<Scalars['String']>,
+  readonly pdbx_number_of_molecules?: Maybe<Scalars['Int']>,
+};
+
+export type RcsbNonpolymerEntityContainerIdentifiers = {
+  readonly __typename?: 'RcsbNonpolymerEntityContainerIdentifiers',
+  readonly asym_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly auth_asym_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly entity_id: Scalars['String'],
+  readonly entry_id: Scalars['String'],
+  readonly nonpolymer_comp_id?: Maybe<Scalars['String']>,
+  readonly prd_id?: Maybe<Scalars['String']>,
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+  readonly reference_chemical_identifiers_provenance_source?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly reference_chemical_identifiers_resource_accession?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly reference_chemical_identifiers_resource_name?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+};
+
+export type RcsbNonpolymerEntityFeature = {
+  readonly __typename?: 'RcsbNonpolymerEntityFeature',
+  readonly assignment_version?: Maybe<Scalars['String']>,
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly feature_class_lineage?: Maybe<ReadonlyArray<Maybe<RcsbNonpolymerEntityFeatureFeatureClassLineage>>>,
+  readonly feature_id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+  readonly value?: Maybe<Scalars['Float']>,
+};
+
+export type RcsbNonpolymerEntityFeatureFeatureClassLineage = {
+  readonly __typename?: 'RcsbNonpolymerEntityFeatureFeatureClassLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerEntityFeatureSummary = {
+  readonly __typename?: 'RcsbNonpolymerEntityFeatureSummary',
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly count?: Maybe<Scalars['Int']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerEntityInstanceContainerIdentifiers = {
+  readonly __typename?: 'RcsbNonpolymerEntityInstanceContainerIdentifiers',
+  readonly asym_id: Scalars['String'],
+  readonly auth_asym_id?: Maybe<Scalars['String']>,
+  readonly auth_seq_id?: Maybe<Scalars['String']>,
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly entity_id?: Maybe<Scalars['String']>,
+  readonly entry_id: Scalars['String'],
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerEntityKeywords = {
+  readonly __typename?: 'RcsbNonpolymerEntityKeywords',
+  readonly text?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerEntityNameCom = {
+  readonly __typename?: 'RcsbNonpolymerEntityNameCom',
+  readonly name: Scalars['String'],
+};
+
+export type RcsbNonpolymerInstanceFeature = {
+  readonly __typename?: 'RcsbNonpolymerInstanceFeature',
+  readonly assignment_version?: Maybe<Scalars['String']>,
+  readonly auth_seq_id?: Maybe<Scalars['String']>,
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly feature_class_lineage?: Maybe<ReadonlyArray<Maybe<RcsbNonpolymerInstanceFeatureFeatureClassLineage>>>,
+  readonly feature_id?: Maybe<Scalars['String']>,
+  readonly feature_value?: Maybe<ReadonlyArray<Maybe<RcsbNonpolymerInstanceFeatureFeatureValue>>>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerInstanceFeatureFeatureClassLineage = {
+  readonly __typename?: 'RcsbNonpolymerInstanceFeatureFeatureClassLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerInstanceFeatureFeatureValue = {
+  readonly __typename?: 'RcsbNonpolymerInstanceFeatureFeatureValue',
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly reference?: Maybe<Scalars['Float']>,
+  readonly reported?: Maybe<Scalars['Float']>,
+  readonly uncertainty_estimate?: Maybe<Scalars['Float']>,
+  readonly uncertainty_estimate_type?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerInstanceFeatureSummary = {
+  readonly __typename?: 'RcsbNonpolymerInstanceFeatureSummary',
+  readonly count?: Maybe<Scalars['Int']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerStructConn = {
+  readonly __typename?: 'RcsbNonpolymerStructConn',
+  readonly connect_partner?: Maybe<RcsbNonpolymerStructConnConnectPartner>,
+  readonly connect_target?: Maybe<RcsbNonpolymerStructConnConnectTarget>,
+  readonly connect_type?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly dist_value?: Maybe<Scalars['Float']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly ordinal_id: Scalars['Int'],
+  readonly value_order?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerStructConnConnectPartner = {
+  readonly __typename?: 'RcsbNonpolymerStructConnConnectPartner',
+  readonly label_alt_id?: Maybe<Scalars['String']>,
+  readonly label_asym_id?: Maybe<Scalars['String']>,
+  readonly label_atom_id?: Maybe<Scalars['String']>,
+  readonly label_comp_id?: Maybe<Scalars['String']>,
+  readonly label_seq_id?: Maybe<Scalars['Int']>,
+  readonly symmetry?: Maybe<Scalars['String']>,
+};
+
+export type RcsbNonpolymerStructConnConnectTarget = {
+  readonly __typename?: 'RcsbNonpolymerStructConnConnectTarget',
+  readonly auth_asym_id?: Maybe<Scalars['String']>,
+  readonly auth_seq_id?: Maybe<Scalars['String']>,
+  readonly label_alt_id?: Maybe<Scalars['String']>,
+  readonly label_asym_id?: Maybe<Scalars['String']>,
+  readonly label_atom_id?: Maybe<Scalars['String']>,
+  readonly label_comp_id?: Maybe<Scalars['String']>,
+  readonly label_seq_id?: Maybe<Scalars['Int']>,
+  readonly symmetry?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPfamContainerIdentifiers = {
+  readonly __typename?: 'RcsbPfamContainerIdentifiers',
+  readonly pfam_id?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntity = {
+  readonly __typename?: 'RcsbPolymerEntity',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly formula_weight?: Maybe<Scalars['Float']>,
+  readonly pdbx_description?: Maybe<Scalars['String']>,
+  readonly pdbx_ec?: Maybe<Scalars['String']>,
+  readonly pdbx_fragment?: Maybe<Scalars['String']>,
+  readonly pdbx_mutation?: Maybe<Scalars['String']>,
+  readonly pdbx_number_of_molecules?: Maybe<Scalars['Int']>,
+  readonly rcsb_ec_lineage?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityRcsbEcLineage>>>,
+  readonly rcsb_macromolecular_names_combined?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityRcsbMacromolecularNamesCombined>>>,
+  readonly rcsb_multiple_source_flag?: Maybe<Scalars['String']>,
+  readonly rcsb_source_part_count?: Maybe<Scalars['Int']>,
+  readonly src_method?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityAlign = {
+  readonly __typename?: 'RcsbPolymerEntityAlign',
+  readonly aligned_regions?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityAlignAlignedRegions>>>,
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly reference_database_accession?: Maybe<Scalars['String']>,
+  readonly reference_database_isoform?: Maybe<Scalars['String']>,
+  readonly reference_database_name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityAlignAlignedRegions = {
+  readonly __typename?: 'RcsbPolymerEntityAlignAlignedRegions',
+  readonly entity_beg_seq_id?: Maybe<Scalars['Int']>,
+  readonly length?: Maybe<Scalars['Int']>,
+  readonly ref_beg_seq_id?: Maybe<Scalars['Int']>,
+};
+
+export type RcsbPolymerEntityContainerIdentifiers = {
+  readonly __typename?: 'RcsbPolymerEntityContainerIdentifiers',
+  readonly asym_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly auth_asym_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly chem_comp_monomers?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly chem_comp_nstd_monomers?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly entity_id: Scalars['String'],
+  readonly entry_id: Scalars['String'],
+  readonly go_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly pfam_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly prd_id?: Maybe<Scalars['String']>,
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+  readonly reference_sequence_identifiers?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityContainerIdentifiersReferenceSequenceIdentifiers>>>,
+  readonly related_annotation_identifiers?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityContainerIdentifiersRelatedAnnotationIdentifiers>>>,
+  readonly related_annotation_lineage?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityContainerIdentifiersRelatedAnnotationLineage>>>,
+  readonly uniprot_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+};
+
+export type RcsbPolymerEntityContainerIdentifiersReferenceSequenceIdentifiers = {
+  readonly __typename?: 'RcsbPolymerEntityContainerIdentifiersReferenceSequenceIdentifiers',
+  readonly database_accession?: Maybe<Scalars['String']>,
+  readonly database_isoform?: Maybe<Scalars['String']>,
+  readonly database_name?: Maybe<Scalars['String']>,
+  readonly provenance_source?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityContainerIdentifiersRelatedAnnotationIdentifiers = {
+  readonly __typename?: 'RcsbPolymerEntityContainerIdentifiersRelatedAnnotationIdentifiers',
+  readonly provenance_source?: Maybe<Scalars['String']>,
+  readonly resource_identifier?: Maybe<Scalars['String']>,
+  readonly resource_name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityContainerIdentifiersRelatedAnnotationLineage = {
+  readonly __typename?: 'RcsbPolymerEntityContainerIdentifiersRelatedAnnotationLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly resource?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityFeature = {
+  readonly __typename?: 'RcsbPolymerEntityFeature',
+  readonly assignment_version?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly feature_class_lineage?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityFeatureFeatureClassLineage>>>,
+  readonly feature_id?: Maybe<Scalars['String']>,
+  readonly feature_positions?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityFeatureFeaturePositions>>>,
+  readonly feature_ranges?: Maybe<ReadonlyArray<Maybe<RcsbPolymerEntityFeatureFeatureRanges>>>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly reference_scheme?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityFeatureFeatureClassLineage = {
+  readonly __typename?: 'RcsbPolymerEntityFeatureFeatureClassLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityFeatureFeaturePositions = {
+  readonly __typename?: 'RcsbPolymerEntityFeatureFeaturePositions',
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly seq_id?: Maybe<Scalars['Int']>,
+  readonly value?: Maybe<Scalars['Float']>,
+};
+
+export type RcsbPolymerEntityFeatureFeatureRanges = {
+  readonly __typename?: 'RcsbPolymerEntityFeatureFeatureRanges',
+  readonly beg_seq_id?: Maybe<Scalars['Int']>,
+  readonly end_seq_id?: Maybe<Scalars['Int']>,
+  readonly value?: Maybe<Scalars['Float']>,
+};
+
+export type RcsbPolymerEntityFeatureSummary = {
+  readonly __typename?: 'RcsbPolymerEntityFeatureSummary',
+  readonly count?: Maybe<Scalars['Int']>,
+  readonly coverage?: Maybe<Scalars['Float']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityInstanceContainerIdentifiers = {
+  readonly __typename?: 'RcsbPolymerEntityInstanceContainerIdentifiers',
+  readonly asym_id: Scalars['String'],
+  readonly auth_asym_id?: Maybe<Scalars['String']>,
+  readonly entity_id?: Maybe<Scalars['String']>,
+  readonly entry_id: Scalars['String'],
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityKeywords = {
+  readonly __typename?: 'RcsbPolymerEntityKeywords',
+  readonly text?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityNameCom = {
+  readonly __typename?: 'RcsbPolymerEntityNameCom',
+  readonly name: Scalars['String'],
+};
+
+export type RcsbPolymerEntityNameSys = {
+  readonly __typename?: 'RcsbPolymerEntityNameSys',
+  readonly name: Scalars['String'],
+  readonly system?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityRcsbEcLineage = {
+  readonly __typename?: 'RcsbPolymerEntityRcsbEcLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerEntityRcsbMacromolecularNamesCombined = {
+  readonly __typename?: 'RcsbPolymerEntityRcsbMacromolecularNamesCombined',
+  readonly name?: Maybe<Scalars['String']>,
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly provenance_source?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerInstanceFeature = {
+  readonly __typename?: 'RcsbPolymerInstanceFeature',
+  readonly assignment_version?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly feature_class_lineage?: Maybe<ReadonlyArray<Maybe<RcsbPolymerInstanceFeatureFeatureClassLineage>>>,
+  readonly feature_id?: Maybe<Scalars['String']>,
+  readonly feature_positions?: Maybe<ReadonlyArray<Maybe<RcsbPolymerInstanceFeatureFeaturePositions>>>,
+  readonly feature_ranges?: Maybe<ReadonlyArray<Maybe<RcsbPolymerInstanceFeatureFeatureRanges>>>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly ordinal: Scalars['Int'],
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly reference_scheme?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerInstanceFeatureFeatureClassLineage = {
+  readonly __typename?: 'RcsbPolymerInstanceFeatureFeatureClassLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerInstanceFeatureFeaturePositions = {
+  readonly __typename?: 'RcsbPolymerInstanceFeatureFeaturePositions',
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly seq_id?: Maybe<Scalars['Int']>,
+  readonly value?: Maybe<Scalars['Float']>,
+};
+
+export type RcsbPolymerInstanceFeatureFeatureRanges = {
+  readonly __typename?: 'RcsbPolymerInstanceFeatureFeatureRanges',
+  readonly beg_seq_id?: Maybe<Scalars['Int']>,
+  readonly end_seq_id?: Maybe<Scalars['Int']>,
+  readonly value?: Maybe<Scalars['Float']>,
+};
+
+export type RcsbPolymerInstanceFeatureSummary = {
+  readonly __typename?: 'RcsbPolymerInstanceFeatureSummary',
+  readonly count?: Maybe<Scalars['Int']>,
+  readonly coverage?: Maybe<Scalars['Float']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerStructConn = {
+  readonly __typename?: 'RcsbPolymerStructConn',
+  readonly connect_partner?: Maybe<RcsbPolymerStructConnConnectPartner>,
+  readonly connect_target?: Maybe<RcsbPolymerStructConnConnectTarget>,
+  readonly connect_type?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly dist_value?: Maybe<Scalars['Float']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly ordinal_id: Scalars['Int'],
+  readonly value_order?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerStructConnConnectPartner = {
+  readonly __typename?: 'RcsbPolymerStructConnConnectPartner',
+  readonly label_alt_id?: Maybe<Scalars['String']>,
+  readonly label_asym_id?: Maybe<Scalars['String']>,
+  readonly label_atom_id?: Maybe<Scalars['String']>,
+  readonly label_comp_id?: Maybe<Scalars['String']>,
+  readonly label_seq_id?: Maybe<Scalars['Int']>,
+  readonly symmetry?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPolymerStructConnConnectTarget = {
+  readonly __typename?: 'RcsbPolymerStructConnConnectTarget',
+  readonly auth_asym_id?: Maybe<Scalars['String']>,
+  readonly auth_seq_id?: Maybe<Scalars['String']>,
+  readonly label_alt_id?: Maybe<Scalars['String']>,
+  readonly label_asym_id?: Maybe<Scalars['String']>,
+  readonly label_atom_id?: Maybe<Scalars['String']>,
+  readonly label_comp_id?: Maybe<Scalars['String']>,
+  readonly label_seq_id?: Maybe<Scalars['Int']>,
+  readonly symmetry?: Maybe<Scalars['String']>,
+};
+
+export type RcsbPubmedContainerIdentifiers = {
+  readonly __typename?: 'RcsbPubmedContainerIdentifiers',
+  readonly pubmed_id?: Maybe<Scalars['Int']>,
+};
+
+export type RcsbPubmedMeshDescriptorsLineage = {
+  readonly __typename?: 'RcsbPubmedMeshDescriptorsLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbRepositoryHoldingsCurrent = {
+  readonly __typename?: 'RcsbRepositoryHoldingsCurrent',
+  readonly repository_content_types?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+};
+
+export type RcsbRepositoryHoldingsCurrentEntryContainerIdentifiers = {
+  readonly __typename?: 'RcsbRepositoryHoldingsCurrentEntryContainerIdentifiers',
+  readonly assembly_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly entry_id: Scalars['String'],
+  readonly rcsb_id?: Maybe<Scalars['String']>,
+  readonly update_id?: Maybe<Scalars['String']>,
+};
+
+export type RcsbSchemaContainerIdentifiers = {
+  readonly __typename?: 'RcsbSchemaContainerIdentifiers',
+  readonly collection_name: Scalars['String'],
+  readonly collection_schema_version?: Maybe<Scalars['String']>,
+  readonly schema_name: Scalars['String'],
+};
+
+export type RcsbStructSymmetry = {
+  readonly __typename?: 'RcsbStructSymmetry',
+  readonly clusters: ReadonlyArray<Maybe<RcsbStructSymmetryClusters>>,
+  readonly kind: Scalars['String'],
+  readonly oligomeric_state: Scalars['String'],
+  readonly rotation_axes?: Maybe<ReadonlyArray<Maybe<RcsbStructSymmetryRotationAxes>>>,
+  readonly stoichiometry: ReadonlyArray<Maybe<Scalars['String']>>,
+  readonly symbol: Scalars['String'],
+  readonly type: Scalars['String'],
+};
+
+export type RcsbStructSymmetryClusters = {
+  readonly __typename?: 'RcsbStructSymmetryClusters',
+  readonly avg_rmsd?: Maybe<Scalars['Float']>,
+  readonly members: ReadonlyArray<Maybe<ClustersMembers>>,
+};
+
+export type RcsbStructSymmetryLineage = {
+  readonly __typename?: 'RcsbStructSymmetryLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbStructSymmetryRotationAxes = {
+  readonly __typename?: 'RcsbStructSymmetryRotationAxes',
+  readonly end: ReadonlyArray<Maybe<Scalars['Float']>>,
+  readonly order?: Maybe<Scalars['Int']>,
+  readonly start: ReadonlyArray<Maybe<Scalars['Float']>>,
+};
+
+export type RcsbUniprotContainerIdentifiers = {
+  readonly __typename?: 'RcsbUniprotContainerIdentifiers',
+  readonly ensembl_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly go_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly pfam_ids?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly uniprot_id?: Maybe<Scalars['String']>,
+};
+
+export type RcsbUniprotFeature = {
+  readonly __typename?: 'RcsbUniprotFeature',
+  readonly assignment_version?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly feature_class_lineage?: Maybe<ReadonlyArray<Maybe<RcsbUniprotFeatureFeatureClassLineage>>>,
+  readonly feature_id?: Maybe<Scalars['String']>,
+  readonly feature_positions?: Maybe<ReadonlyArray<Maybe<RcsbUniprotFeatureFeaturePositions>>>,
+  readonly feature_ranges?: Maybe<ReadonlyArray<Maybe<RcsbUniprotFeatureFeatureRanges>>>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly provenance_code?: Maybe<Scalars['String']>,
+  readonly reference_scheme?: Maybe<Scalars['String']>,
+  readonly type?: Maybe<Scalars['String']>,
+};
+
+export type RcsbUniprotFeatureFeatureClassLineage = {
+  readonly __typename?: 'RcsbUniprotFeatureFeatureClassLineage',
+  readonly depth?: Maybe<Scalars['Int']>,
+  readonly id?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+};
+
+export type RcsbUniprotFeatureFeaturePositions = {
+  readonly __typename?: 'RcsbUniprotFeatureFeaturePositions',
+  readonly comp_id?: Maybe<Scalars['String']>,
+  readonly seq_id?: Maybe<Scalars['Int']>,
+  readonly value?: Maybe<Scalars['Float']>,
+};
+
+export type RcsbUniprotFeatureFeatureRanges = {
+  readonly __typename?: 'RcsbUniprotFeatureFeatureRanges',
+  readonly beg_seq_id?: Maybe<Scalars['Int']>,
+  readonly end_seq_id?: Maybe<Scalars['Int']>,
+  readonly value?: Maybe<Scalars['Float']>,
+};
+
+export type RcsbUniprotKeyword = {
+  readonly __typename?: 'RcsbUniprotKeyword',
+  readonly id?: Maybe<Scalars['String']>,
+  readonly value?: Maybe<Scalars['String']>,
+};
+
+export type RcsbUniprotProtein = {
+  readonly __typename?: 'RcsbUniprotProtein',
+  readonly ec?: Maybe<ReadonlyArray<Maybe<RcsbUniprotProteinEc>>>,
+  readonly function?: Maybe<RcsbUniprotProteinFunction>,
+  readonly gene?: Maybe<ReadonlyArray<Maybe<RcsbUniprotProteinGene>>>,
+  readonly name?: Maybe<RcsbUniprotProteinName>,
+  readonly sequence?: Maybe<Scalars['String']>,
+  readonly source_organism?: Maybe<RcsbUniprotProteinSourceOrganism>,
+};
+
+export type RcsbUniprotProteinEc = {
+  readonly __typename?: 'RcsbUniprotProteinEc',
+  readonly number?: Maybe<Scalars['String']>,
+  readonly provenance_code?: Maybe<Scalars['String']>,
+};
+
+export type RcsbUniprotProteinFunction = {
+  readonly __typename?: 'RcsbUniprotProteinFunction',
+  readonly details?: Maybe<Scalars['String']>,
+  readonly provenance_code?: Maybe<Scalars['String']>,
+};
+
+export type RcsbUniprotProteinGene = {
+  readonly __typename?: 'RcsbUniprotProteinGene',
+  readonly name?: Maybe<ReadonlyArray<Maybe<GeneName>>>,
+};
+
+export type RcsbUniprotProteinName = {
+  readonly __typename?: 'RcsbUniprotProteinName',
+  readonly provenance_code: Scalars['String'],
+  readonly value: Scalars['String'],
+};
+
+export type RcsbUniprotProteinSourceOrganism = {
+  readonly __typename?: 'RcsbUniprotProteinSourceOrganism',
+  readonly provenance_code: Scalars['String'],
+  readonly scientific_name: Scalars['String'],
+  readonly taxonomy_id?: Maybe<Scalars['Int']>,
+};
+
+export type Refine = {
+  readonly __typename?: 'Refine',
+  readonly B_iso_max?: Maybe<Scalars['Float']>,
+  readonly B_iso_mean?: Maybe<Scalars['Float']>,
+  readonly B_iso_min?: Maybe<Scalars['Float']>,
+  readonly aniso_B_1_1?: Maybe<Scalars['Float']>,
+  readonly aniso_B_1_2?: Maybe<Scalars['Float']>,
+  readonly aniso_B_1_3?: Maybe<Scalars['Float']>,
+  readonly aniso_B_2_2?: Maybe<Scalars['Float']>,
+  readonly aniso_B_2_3?: Maybe<Scalars['Float']>,
+  readonly aniso_B_3_3?: Maybe<Scalars['Float']>,
+  readonly correlation_coeff_Fo_to_Fc?: Maybe<Scalars['Float']>,
+  readonly correlation_coeff_Fo_to_Fc_free?: Maybe<Scalars['Float']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly ls_R_factor_R_free?: Maybe<Scalars['Float']>,
+  readonly ls_R_factor_R_free_error?: Maybe<Scalars['Float']>,
+  readonly ls_R_factor_R_free_error_details?: Maybe<Scalars['String']>,
+  readonly ls_R_factor_R_work?: Maybe<Scalars['Float']>,
+  readonly ls_R_factor_all?: Maybe<Scalars['Float']>,
+  readonly ls_R_factor_obs?: Maybe<Scalars['Float']>,
+  readonly ls_d_res_high?: Maybe<Scalars['Float']>,
+  readonly ls_d_res_low?: Maybe<Scalars['Float']>,
+  readonly ls_matrix_type?: Maybe<Scalars['String']>,
+  readonly ls_number_parameters?: Maybe<Scalars['Int']>,
+  readonly ls_number_reflns_R_free?: Maybe<Scalars['Int']>,
+  readonly ls_number_reflns_R_work?: Maybe<Scalars['Int']>,
+  readonly ls_number_reflns_all?: Maybe<Scalars['Int']>,
+  readonly ls_number_reflns_obs?: Maybe<Scalars['Int']>,
+  readonly ls_number_restraints?: Maybe<Scalars['Int']>,
+  readonly ls_percent_reflns_R_free?: Maybe<Scalars['Float']>,
+  readonly ls_percent_reflns_obs?: Maybe<Scalars['Float']>,
+  readonly ls_redundancy_reflns_all?: Maybe<Scalars['Float']>,
+  readonly ls_redundancy_reflns_obs?: Maybe<Scalars['Float']>,
+  readonly ls_wR_factor_R_free?: Maybe<Scalars['Float']>,
+  readonly ls_wR_factor_R_work?: Maybe<Scalars['Float']>,
+  readonly occupancy_max?: Maybe<Scalars['Float']>,
+  readonly occupancy_min?: Maybe<Scalars['Float']>,
+  readonly overall_FOM_free_R_set?: Maybe<Scalars['Float']>,
+  readonly overall_FOM_work_R_set?: Maybe<Scalars['Float']>,
+  readonly overall_SU_B?: Maybe<Scalars['Float']>,
+  readonly overall_SU_ML?: Maybe<Scalars['Float']>,
+  readonly overall_SU_R_Cruickshank_DPI?: Maybe<Scalars['Float']>,
+  readonly overall_SU_R_free?: Maybe<Scalars['Float']>,
+  readonly pdbx_R_Free_selection_details?: Maybe<Scalars['String']>,
+  readonly pdbx_TLS_residual_ADP_flag?: Maybe<Scalars['String']>,
+  readonly pdbx_average_fsc_free?: Maybe<Scalars['Float']>,
+  readonly pdbx_average_fsc_overall?: Maybe<Scalars['Float']>,
+  readonly pdbx_average_fsc_work?: Maybe<Scalars['Float']>,
+  readonly pdbx_data_cutoff_high_absF?: Maybe<Scalars['Float']>,
+  readonly pdbx_data_cutoff_high_rms_absF?: Maybe<Scalars['Float']>,
+  readonly pdbx_data_cutoff_low_absF?: Maybe<Scalars['Float']>,
+  readonly pdbx_diffrn_id?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly pdbx_isotropic_thermal_model?: Maybe<Scalars['String']>,
+  readonly pdbx_ls_cross_valid_method?: Maybe<Scalars['String']>,
+  readonly pdbx_ls_sigma_F?: Maybe<Scalars['Float']>,
+  readonly pdbx_ls_sigma_Fsqd?: Maybe<Scalars['Float']>,
+  readonly pdbx_ls_sigma_I?: Maybe<Scalars['Float']>,
+  readonly pdbx_method_to_determine_struct?: Maybe<Scalars['String']>,
+  readonly pdbx_overall_ESU_R?: Maybe<Scalars['Float']>,
+  readonly pdbx_overall_ESU_R_Free?: Maybe<Scalars['Float']>,
+  readonly pdbx_overall_SU_R_Blow_DPI?: Maybe<Scalars['Float']>,
+  readonly pdbx_overall_SU_R_free_Blow_DPI?: Maybe<Scalars['Float']>,
+  readonly pdbx_overall_SU_R_free_Cruickshank_DPI?: Maybe<Scalars['Float']>,
+  readonly pdbx_overall_phase_error?: Maybe<Scalars['Float']>,
+  readonly pdbx_refine_id: Scalars['String'],
+  readonly pdbx_solvent_ion_probe_radii?: Maybe<Scalars['Float']>,
+  readonly pdbx_solvent_shrinkage_radii?: Maybe<Scalars['Float']>,
+  readonly pdbx_solvent_vdw_probe_radii?: Maybe<Scalars['Float']>,
+  readonly pdbx_starting_model?: Maybe<Scalars['String']>,
+  readonly pdbx_stereochem_target_val_spec_case?: Maybe<Scalars['String']>,
+  readonly pdbx_stereochemistry_target_values?: Maybe<Scalars['String']>,
+  readonly solvent_model_details?: Maybe<Scalars['String']>,
+  readonly solvent_model_param_bsol?: Maybe<Scalars['Float']>,
+  readonly solvent_model_param_ksol?: Maybe<Scalars['Float']>,
+};
+
+export type RefineAnalyze = {
+  readonly __typename?: 'RefineAnalyze',
+  readonly Luzzati_coordinate_error_free?: Maybe<Scalars['Float']>,
+  readonly Luzzati_coordinate_error_obs?: Maybe<Scalars['Float']>,
+  readonly Luzzati_d_res_low_free?: Maybe<Scalars['Float']>,
+  readonly Luzzati_d_res_low_obs?: Maybe<Scalars['Float']>,
+  readonly Luzzati_sigma_a_free?: Maybe<Scalars['Float']>,
+  readonly Luzzati_sigma_a_obs?: Maybe<Scalars['Float']>,
+  readonly number_disordered_residues?: Maybe<Scalars['Float']>,
+  readonly occupancy_sum_hydrogen?: Maybe<Scalars['Float']>,
+  readonly occupancy_sum_non_hydrogen?: Maybe<Scalars['Float']>,
+  readonly pdbx_Luzzati_d_res_high_obs?: Maybe<Scalars['Float']>,
+  readonly pdbx_refine_id: Scalars['String'],
+};
+
+export type RefineHist = {
+  readonly __typename?: 'RefineHist',
+  readonly cycle_id: Scalars['String'],
+  readonly d_res_high?: Maybe<Scalars['Float']>,
+  readonly d_res_low?: Maybe<Scalars['Float']>,
+  readonly number_atoms_solvent?: Maybe<Scalars['Int']>,
+  readonly number_atoms_total?: Maybe<Scalars['Int']>,
+  readonly pdbx_B_iso_mean_ligand?: Maybe<Scalars['Float']>,
+  readonly pdbx_B_iso_mean_solvent?: Maybe<Scalars['Float']>,
+  readonly pdbx_number_atoms_ligand?: Maybe<Scalars['Int']>,
+  readonly pdbx_number_atoms_nucleic_acid?: Maybe<Scalars['Int']>,
+  readonly pdbx_number_atoms_protein?: Maybe<Scalars['Int']>,
+  readonly pdbx_number_residues_total?: Maybe<Scalars['Int']>,
+  readonly pdbx_refine_id: Scalars['String'],
+};
+
+export type RefineLsRestr = {
+  readonly __typename?: 'RefineLsRestr',
+  readonly dev_ideal?: Maybe<Scalars['Float']>,
+  readonly dev_ideal_target?: Maybe<Scalars['Float']>,
+  readonly number?: Maybe<Scalars['Int']>,
+  readonly pdbx_refine_id: Scalars['String'],
+  readonly pdbx_restraint_function?: Maybe<Scalars['String']>,
+  readonly type: Scalars['String'],
+  readonly weight?: Maybe<Scalars['Float']>,
+};
+
+export type Reflns = {
+  readonly __typename?: 'Reflns',
+  readonly B_iso_Wilson_estimate?: Maybe<Scalars['Float']>,
+  readonly R_free_details?: Maybe<Scalars['String']>,
+  readonly Rmerge_F_all?: Maybe<Scalars['Float']>,
+  readonly Rmerge_F_obs?: Maybe<Scalars['Float']>,
+  readonly d_resolution_high?: Maybe<Scalars['Float']>,
+  readonly d_resolution_low?: Maybe<Scalars['Float']>,
+  readonly data_reduction_details?: Maybe<Scalars['String']>,
+  readonly data_reduction_method?: Maybe<Scalars['String']>,
+  readonly details?: Maybe<Scalars['String']>,
+  readonly limit_h_max?: Maybe<Scalars['Int']>,
+  readonly limit_h_min?: Maybe<Scalars['Int']>,
+  readonly limit_k_max?: Maybe<Scalars['Int']>,
+  readonly limit_k_min?: Maybe<Scalars['Int']>,
+  readonly limit_l_max?: Maybe<Scalars['Int']>,
+  readonly limit_l_min?: Maybe<Scalars['Int']>,
+  readonly number_all?: Maybe<Scalars['Int']>,
+  readonly number_obs?: Maybe<Scalars['Int']>,
+  readonly observed_criterion?: Maybe<Scalars['String']>,
+  readonly observed_criterion_F_max?: Maybe<Scalars['Float']>,
+  readonly observed_criterion_F_min?: Maybe<Scalars['Float']>,
+  readonly observed_criterion_I_max?: Maybe<Scalars['Float']>,
+  readonly observed_criterion_I_min?: Maybe<Scalars['Float']>,
+  readonly observed_criterion_sigma_F?: Maybe<Scalars['Float']>,
+  readonly observed_criterion_sigma_I?: Maybe<Scalars['Float']>,
+  readonly pdbx_CC_half?: Maybe<Scalars['Float']>,
+  readonly pdbx_R_split?: Maybe<Scalars['Float']>,
+  readonly pdbx_Rmerge_I_obs?: Maybe<Scalars['Float']>,
+  readonly pdbx_Rpim_I_all?: Maybe<Scalars['Float']>,
+  readonly pdbx_Rrim_I_all?: Maybe<Scalars['Float']>,
+  readonly pdbx_Rsym_value?: Maybe<Scalars['Float']>,
+  readonly pdbx_chi_squared?: Maybe<Scalars['Float']>,
+  readonly pdbx_diffrn_id?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly pdbx_netI_over_av_sigmaI?: Maybe<Scalars['Float']>,
+  readonly pdbx_netI_over_sigmaI?: Maybe<Scalars['Float']>,
+  readonly pdbx_number_measured_all?: Maybe<Scalars['Int']>,
+  readonly pdbx_ordinal: Scalars['Int'],
+  readonly pdbx_redundancy?: Maybe<Scalars['Float']>,
+  readonly pdbx_scaling_rejects?: Maybe<Scalars['Int']>,
+  readonly percent_possible_obs?: Maybe<Scalars['Float']>,
+  readonly phase_calculation_details?: Maybe<Scalars['String']>,
+};
+
+export type ReflnsShell = {
+  readonly __typename?: 'ReflnsShell',
+  readonly Rmerge_F_all?: Maybe<Scalars['Float']>,
+  readonly Rmerge_F_obs?: Maybe<Scalars['Float']>,
+  readonly Rmerge_I_all?: Maybe<Scalars['Float']>,
+  readonly Rmerge_I_obs?: Maybe<Scalars['Float']>,
+  readonly d_res_high?: Maybe<Scalars['Float']>,
+  readonly d_res_low?: Maybe<Scalars['Float']>,
+  readonly meanI_over_sigI_all?: Maybe<Scalars['Float']>,
+  readonly meanI_over_sigI_obs?: Maybe<Scalars['Float']>,
+  readonly meanI_over_uI_all?: Maybe<Scalars['Float']>,
+  readonly number_measured_all?: Maybe<Scalars['Int']>,
+  readonly number_measured_obs?: Maybe<Scalars['Int']>,
+  readonly number_possible?: Maybe<Scalars['Int']>,
+  readonly number_unique_all?: Maybe<Scalars['Int']>,
+  readonly number_unique_obs?: Maybe<Scalars['Int']>,
+  readonly pdbx_CC_half?: Maybe<Scalars['Float']>,
+  readonly pdbx_R_split?: Maybe<Scalars['Float']>,
+  readonly pdbx_Rpim_I_all?: Maybe<Scalars['Float']>,
+  readonly pdbx_Rrim_I_all?: Maybe<Scalars['Float']>,
+  readonly pdbx_Rsym_value?: Maybe<Scalars['Float']>,
+  readonly pdbx_chi_squared?: Maybe<Scalars['Float']>,
+  readonly pdbx_diffrn_id?: Maybe<ReadonlyArray<Maybe<Scalars['String']>>>,
+  readonly pdbx_netI_over_sigmaI_all?: Maybe<Scalars['Float']>,
+  readonly pdbx_netI_over_sigmaI_obs?: Maybe<Scalars['Float']>,
+  readonly pdbx_ordinal: Scalars['Int'],
+  readonly pdbx_redundancy?: Maybe<Scalars['Float']>,
+  readonly pdbx_rejects?: Maybe<Scalars['Int']>,
+  readonly percent_possible_all?: Maybe<Scalars['Float']>,
+  readonly percent_possible_obs?: Maybe<Scalars['Float']>,
+};
+
+export type Software = {
+  readonly __typename?: 'Software',
+  readonly classification?: Maybe<Scalars['String']>,
+  readonly contact_author?: Maybe<Scalars['String']>,
+  readonly contact_author_email?: Maybe<Scalars['String']>,
+  readonly date?: Maybe<Scalars['String']>,
+  readonly description?: Maybe<Scalars['String']>,
+  readonly language?: Maybe<Scalars['String']>,
+  readonly location?: Maybe<Scalars['String']>,
+  readonly name?: Maybe<Scalars['String']>,
+  readonly os?: Maybe<Scalars['String']>,
+  readonly pdbx_ordinal: Scalars['Int'],
+  readonly type?: Maybe<Scalars['String']>,
+  readonly version?: Maybe<Scalars['String']>,
+};
+
+export type Struct = {
+  readonly __typename?: 'Struct',
+  readonly pdbx_CASP_flag?: Maybe<Scalars['String']>,
+  readonly pdbx_descriptor?: Maybe<Scalars['String']>,
+  readonly pdbx_model_details?: Maybe<Scalars['String']>,
+  readonly pdbx_model_type_details?: Maybe<Scalars['String']>,
+  readonly title?: Maybe<Scalars['String']>,
+};
+
+export type StructKeywords = {
+  readonly __typename?: 'StructKeywords',
+  readonly pdbx_keywords?: Maybe<Scalars['String']>,
+  readonly text?: Maybe<Scalars['String']>,
+};
+
+export type Symmetry = {
+  readonly __typename?: 'Symmetry',
+  readonly Int_Tables_number?: Maybe<Scalars['Int']>,
+  readonly cell_setting?: Maybe<Scalars['String']>,
+  readonly pdbx_full_space_group_name_H_M?: Maybe<Scalars['String']>,
+  readonly space_group_name_H_M?: Maybe<Scalars['String']>,
+  readonly space_group_name_Hall?: Maybe<Scalars['String']>,
+};
+
+
+export type AssemblySymmetryQueryVariables = {
+  assembly_id: Scalars['String'],
+  entry_id: Scalars['String']
+};
+
+
+export type AssemblySymmetryQuery = (
+  { readonly __typename?: 'Query' }
+  & { readonly assembly: Maybe<(
+    { readonly __typename?: 'CoreAssembly' }
+    & { readonly rcsb_struct_symmetry: Maybe<ReadonlyArray<Maybe<(
+      { readonly __typename?: 'RcsbStructSymmetry' }
+      & Pick<RcsbStructSymmetry, 'kind' | 'oligomeric_state' | 'stoichiometry' | 'symbol' | 'type'>
+      & { readonly clusters: ReadonlyArray<Maybe<(
+        { readonly __typename?: 'RcsbStructSymmetryClusters' }
+        & Pick<RcsbStructSymmetryClusters, 'avg_rmsd'>
+        & { readonly members: ReadonlyArray<Maybe<(
+          { readonly __typename?: 'ClustersMembers' }
+          & Pick<ClustersMembers, 'asym_id' | 'pdbx_struct_oper_list_ids'>
+        )>> }
+      )>>, readonly rotation_axes: Maybe<ReadonlyArray<Maybe<(
+        { readonly __typename?: 'RcsbStructSymmetryRotationAxes' }
+        & Pick<RcsbStructSymmetryRotationAxes, 'order' | 'start' | 'end'>
+      )>>> }
+    )>>> }
+  )> }
+);

src/mol-model-props/rcsb/graphql/types.ts

@@ -1,88 +0,0 @@
-// Generated in 2019-08-09T10:26:08-07:00
-export type Maybe<T> = T | null;
-
-/** Built-in scalar representing an instant in time */
-export type Date = any;
-
-/** Unrepresentable type */
-export type Unrepresentable = any;
-
-// ====================================================
-// Documents
-// ====================================================
-
-export namespace AssemblySymmetry {
-    export type Variables = {
-        pdbId: string;
-    };
-
-    export type Query = {
-        __typename?: 'Query';
-
-        entry: Maybe<Entry>;
-    };
-
-    export type Entry = {
-        __typename?: 'CoreEntry';
-
-        assemblies: Maybe<(Maybe<Assemblies>)[]>;
-    };
-
-    export type Assemblies = {
-        __typename?: 'CoreAssembly';
-
-        pdbx_struct_assembly: Maybe<PdbxStructAssembly>;
-
-        rcsb_struct_symmetry: Maybe<(Maybe<RcsbStructSymmetry>)[]>;
-    };
-
-    export type PdbxStructAssembly = {
-        __typename?: 'PdbxStructAssembly';
-
-        id: string;
-    };
-
-    export type RcsbStructSymmetry = {
-        __typename?: 'RcsbStructSymmetry';
-
-        clusters: (Maybe<Clusters>)[];
-
-        kind: string;
-
-        oligomeric_state: string;
-
-        rotation_axes: Maybe<(Maybe<RotationAxes>)[]>;
-
-        stoichiometry: (Maybe<string>)[];
-
-        symbol: string;
-
-        type: string;
-    };
-
-    export type Clusters = {
-        __typename?: 'RcsbStructSymmetryClusters';
-
-        avg_rmsd: Maybe<number>;
-
-        members: (Maybe<Members>)[];
-    };
-
-    export type Members = {
-        __typename?: 'ClustersMembers';
-
-        asym_id: string;
-
-        pdbx_struct_oper_list_ids: Maybe<(Maybe<string>)[]>;
-    };
-
-    export type RotationAxes = {
-        __typename?: 'RcsbStructSymmetryRotationAxes';
-
-        start: (Maybe<number>)[];
-
-        end: (Maybe<number>)[];
-
-        order: Maybe<number>;
-    };
-}

src/mol-model-props/rcsb/representations/assembly-symmetry-axes.ts

@@ -1,138 +1,71 @@
 /**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
 import { ParamDefinition as PD } from '../../../mol-util/param-definition';
-import { RepresentationParamsGetter, RepresentationContext } from '../../../mol-repr/representation';
-import { VisualContext } from '../../../mol-repr/visual';
-import { ThemeRegistryContext, Theme } from '../../../mol-theme/theme';
 import { Structure } from '../../../mol-model/structure';
-import { StructureRepresentationProvider, StructureRepresentation, ComplexRepresentation, ComplexVisual } from '../../../mol-repr/structure/representation';
-import { AssemblySymmetry } from '../assembly-symmetry';
-import { Table } from '../../../mol-data/db';
+import { AssemblySymmetryProvider, AssemblySymmetryValue } from '../assembly-symmetry';
 import { MeshBuilder } from '../../../mol-geo/geometry/mesh/mesh-builder';
-import { Tensor, Vec3 } from '../../../mol-math/linear-algebra';
+import { Vec3 } from '../../../mol-math/linear-algebra';
 import { addSphere } from '../../../mol-geo/geometry/mesh/builder/sphere';
 import { addCylinder } from '../../../mol-geo/geometry/mesh/builder/cylinder';
-import { VisualUpdateState } from '../../../mol-repr/util';
-import { ComplexMeshVisual, ComplexMeshParams } from '../../../mol-repr/structure/complex-visual';
 import { Mesh } from '../../../mol-geo/geometry/mesh/mesh';
-import { EmptyLoci, createDataLoci, Loci, isDataLoci } from '../../../mol-model/loci';
-import { LocationIterator } from '../../../mol-geo/util/location-iterator';
-import { NullLocation } from '../../../mol-model/location';
-import { PickingId } from '../../../mol-geo/geometry/picking';
-import { OrderedSet, Interval } from '../../../mol-data/int';
-import { getSymmetrySelectParam, getAssemblyIds } from '../util';
+import { getSymmetrySelectParam } from '../util';
+import { RuntimeContext } from '../../../mol-task';
+import { Shape } from '../../../mol-model/shape';
+import { ColorNames } from '../../../mol-util/color/names';
+import { ShapeRepresentation } from '../../../mol-repr/shape/representation';
 
 export const AssemblySymmetryAxesParams = {
-    symmetryId: getSymmetrySelectParam(),
-    sizeFactor: PD.Numeric(0.4, { min: 0, max: 3, step: 0.01 }),
-
-    ...ComplexMeshParams,
-    radialSegments: PD.Numeric(16, { min: 2, max: 56, step: 2 }),
-    detail: PD.Numeric(0, { min: 0, max: 3, step: 1 }),
+    ...Mesh.Params,
+    axesColor: PD.Color(ColorNames.orange),
+    axesScale: PD.Numeric(2, { min: 0.1, max: 5, step: 0.1 }),
+    symmetryIndex: getSymmetrySelectParam(),
 }
 export type AssemblySymmetryAxesParams = typeof AssemblySymmetryAxesParams
-export function getAssemblySymmetryAxesParams(ctx: ThemeRegistryContext, structure: Structure) {
-    const params = PD.clone(AssemblySymmetryAxesParams)
-    params.symmetryId = getSymmetrySelectParam(structure)
-    params.unitKinds.isHidden = true
-    return params
-}
-
-export type AssemblySymmetryAxesRepresentation = StructureRepresentation<AssemblySymmetryAxesParams>
-export function AssemblySymmetryAxesRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, AssemblySymmetryAxesParams>): AssemblySymmetryAxesRepresentation {
-    return ComplexRepresentation('RCSB Assembly Symmetry Axes', ctx, getParams, AssemblySymmetryAxesVisual)
-}
-
-export const AssemblySymmetryAxesRepresentationProvider: StructureRepresentationProvider<AssemblySymmetryAxesParams> = {
-    label: 'RCSB Assembly Symmetry Axes',
-    description: 'Displays assembly symmetry axes.',
-    factory: AssemblySymmetryAxesRepresentation,
-    getParams: getAssemblySymmetryAxesParams,
-    defaultValues: PD.getDefaultValues(AssemblySymmetryAxesParams),
-    defaultColorTheme: 'uniform',
-    defaultSizeTheme: 'uniform',
-    isApplicable: (structure: Structure) => structure.models.length > 0 && AssemblySymmetry.get(structure.models[0]) !== undefined
-}
-
-//
-
-export function AssemblySymmetryAxesVisual(materialId: number): ComplexVisual<AssemblySymmetryAxesParams> {
-    return ComplexMeshVisual<AssemblySymmetryAxesParams>({
-        defaultProps: PD.getDefaultValues(AssemblySymmetryAxesParams),
-        createGeometry: createAssemblySymmetryAxesMesh,
-        createLocationIterator,
-        getLoci,
-        eachLocation: eachAxisLocation,
-        setUpdateState: (state: VisualUpdateState, newProps: PD.Values<AssemblySymmetryAxesParams>, currentProps: PD.Values<AssemblySymmetryAxesParams>) => {
-            state.createGeometry = (
-                newProps.sizeFactor !== currentProps.sizeFactor ||
-                newProps.detail !== currentProps.detail ||
-                newProps.symmetryId !== currentProps.symmetryId
-            )
-        }
-    }, materialId)
-}
-
-function createLocationIterator(structure: Structure) {
-    const assemblySymmetry = AssemblySymmetry.get(structure.models[0])
-    const groupCount = assemblySymmetry ? assemblySymmetry.db.rcsb_assembly_symmetry_axis._rowCount : 0
-    return LocationIterator(groupCount, 1, () => NullLocation)
-}
-
-function getLoci(pickingId: PickingId, structure: Structure, id: number) {
-    const { objectId, groupId } = pickingId
-    if (id === objectId) {
-        const assemblySymmetry = AssemblySymmetry.get(structure.models[0])
-        if (assemblySymmetry) {
-            return createDataLoci(assemblySymmetry, 'axes', OrderedSet.ofSingleton(groupId))
-        }
-    }
-    return EmptyLoci
-}
-
-function eachAxisLocation(loci: Loci, structure: Structure, apply: (interval: Interval) => boolean) {
-    let changed = false
-    if (!isDataLoci(loci) || loci.tag !== 'axes') return false
-    const assemblySymmetry = AssemblySymmetry.get(structure.models[0])
-    if (!assemblySymmetry || loci.data !== assemblySymmetry) return false
-    OrderedSet.forEach(loci.indices, v => { if (apply(Interval.ofSingleton(v))) changed = true })
-    return changed
-}
-
-export function createAssemblySymmetryAxesMesh(ctx: VisualContext, structure: Structure, theme: Theme, props: PD.Values<AssemblySymmetryAxesParams>, mesh?: Mesh) {
-
-    const { symmetryId, sizeFactor } = props
+export type AssemblySymmetryAxesProps = PD.Values<AssemblySymmetryAxesParams>
 
-    const assemblySymmetry = AssemblySymmetry.get(structure.models[0])
-    if (!assemblySymmetry) return Mesh.createEmpty(mesh)
+function getAxesMesh(data: AssemblySymmetryValue, props: PD.Values<AssemblySymmetryAxesParams>, mesh?: Mesh) {
 
-    const s = assemblySymmetry.db.rcsb_assembly_symmetry
-    const symmetry = Table.pickRow(s, i => s.id.value(i) === symmetryId)
-    if (!symmetry) return Mesh.createEmpty(mesh)
+    const { symmetryIndex, axesScale } = props
 
-    // check if structure.units operators have symmetry.assembly_id
-    if (!getAssemblyIds(structure.units).includes(symmetry.assembly_id)) return Mesh.createEmpty(mesh)
+    const rotation_axes = data?.[symmetryIndex]?.rotation_axes
+    if (!rotation_axes) return Mesh.createEmpty(mesh)
 
-    const axes = assemblySymmetry.db.rcsb_assembly_symmetry_axis
-    const vectorSpace = AssemblySymmetry.Schema.rcsb_assembly_symmetry_axis.start.space;
+    const axis = rotation_axes[0]!
+    const start = axis.start as Vec3
+    const end = axis.end as Vec3
+    const radius = (Vec3.distance(start, end) / 300) * axesScale
 
-    const radius = 1 * sizeFactor
     const cylinderProps = { radiusTop: radius, radiusBottom: radius }
     const builderState = MeshBuilder.createState(256, 128, mesh)
 
-    for (let i = 0, il = axes._rowCount; i < il; ++i) {
-        if (axes.symmetry_id.value(i) !== symmetryId) continue
-
-        const start = Tensor.toVec3(Vec3(), vectorSpace, axes.start.value(i))
-        const end = Tensor.toVec3(Vec3(), vectorSpace, axes.end.value(i))
+    for (let i = 0, il = rotation_axes.length; i < il; ++i) {
+        const axis = rotation_axes[i]!
+        const start = axis.start as Vec3
+        const end = axis.end as Vec3
         builderState.currentGroup = i
         addSphere(builderState, start, radius, 2)
         addSphere(builderState, end, radius, 2)
         addCylinder(builderState, start, end, 1, cylinderProps)
     }
     return MeshBuilder.getMesh(builderState)
+}
+
+export async function getAssemblySymmetryAxesRepresentation(ctx: RuntimeContext, structure: Structure, params: AssemblySymmetryAxesProps, prev?: ShapeRepresentation<AssemblySymmetryValue, Mesh, Mesh.Params>) {
+    const repr = prev || ShapeRepresentation(getAxesShape, Mesh.Utils);
+    const data = AssemblySymmetryProvider.getValue(structure).value
+    await repr.createOrUpdate(params, data).runInContext(ctx);
+    return repr;
+}
+
+function getAxesShape(ctx: RuntimeContext, data: AssemblySymmetryValue, props: AssemblySymmetryAxesProps, shape?: Shape<Mesh>) {
+    const geo = getAxesMesh(data, props, shape && shape.geometry);
+    const getLabel = (groupId: number) => {
+        const { symbol, kind, rotation_axes } = data[props.symmetryIndex]
+        return `Axes ${groupId + 1} of ${symbol} ${kind} with Order ${rotation_axes![groupId]?.order}`
+    }
+    return Shape.create('Unitcell', data, geo, () => props.axesColor, () => 1, getLabel)
 }

src/mol-model-props/rcsb/themes/assembly-symmetry-cluster.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -7,14 +7,14 @@
 import { ThemeDataContext } from '../../../mol-theme/theme';
 import { ColorTheme, LocationColor } from '../../../mol-theme/color';
 import { ParamDefinition as PD } from '../../../mol-util/param-definition'
-import { Table } from '../../../mol-data/db';
-import { AssemblySymmetry } from '../assembly-symmetry';
+import { AssemblySymmetryProvider, AssemblySymmetry } from '../assembly-symmetry';
 import { Color } from '../../../mol-util/color';
 import { Unit, StructureElement, StructureProperties } from '../../../mol-model/structure';
 import { Location } from '../../../mol-model/location';
 import { ScaleLegend, TableLegend } from '../../../mol-util/legend';
 import { getSymmetrySelectParam } from '../util';
 import { getPalette, getPaletteParams } from '../../../mol-util/color/palette';
+import { CustomPropertyContext } from '../../common/custom-property-registry';
 
 const DefaultColor = Color(0xCCCCCC)
 
@@ -28,18 +28,18 @@ function getAsymId(unit: Unit): StructureElement.Property<string> {
     }
 }
 
-function clusterMemberKey(assemblyId: string, asymId: string, operList: string[]) {
-    return `${assemblyId}-${asymId}-${operList.join('|')}`
+function clusterMemberKey(asymId: string, operList: string[]) {
+    return `${asymId}-${operList.join('|')}`
 }
 
 export const AssemblySymmetryClusterColorThemeParams = {
     ...getPaletteParams({ scaleList: 'red-yellow-blue' }),
-    symmetryId: getSymmetrySelectParam(),
+    symmetryIndex: getSymmetrySelectParam(),
 }
 export type AssemblySymmetryClusterColorThemeParams = typeof AssemblySymmetryClusterColorThemeParams
 export function getAssemblySymmetryClusterColorThemeParams(ctx: ThemeDataContext) {
     const params = PD.clone(AssemblySymmetryClusterColorThemeParams)
-    params.symmetryId = getSymmetrySelectParam(ctx.structure)
+    params.symmetryIndex = getSymmetrySelectParam(ctx.structure)
     return params
 }
 
@@ -47,44 +47,35 @@ export function AssemblySymmetryClusterColorTheme(ctx: ThemeDataContext, props:
     let color: LocationColor = () => DefaultColor
     let legend: ScaleLegend | TableLegend | undefined
 
-    const { symmetryId } = props
+    const { symmetryIndex } = props
+    const assemblySymmetry = ctx.structure && AssemblySymmetryProvider.getValue(ctx.structure)
+    const contextHash = assemblySymmetry?.version
 
-    if (ctx.structure && !ctx.structure.isEmpty && ctx.structure.models[0].customProperties.has(AssemblySymmetry.Descriptor)) {
-        const assemblySymmetry = AssemblySymmetry.get(ctx.structure.models[0])!
+    const clusters = assemblySymmetry?.value?.[symmetryIndex]?.clusters
 
-        const s = assemblySymmetry.db.rcsb_assembly_symmetry
-        const symmetry = Table.pickRow(s, i => s.id.value(i) === symmetryId)
-        if (symmetry) {
-
-            const clusters = assemblySymmetry.getClusters(symmetryId)
-            if (clusters._rowCount) {
-
-                const clusterByMember = new Map<string, number>()
-                for (let i = 0, il = clusters._rowCount; i < il; ++i) {
-                    const clusterMembers = assemblySymmetry.getClusterMembers(clusters.id.value(i))
-                    for (let j = 0, jl = clusterMembers._rowCount; j < jl; ++j) {
-                        const asymId = clusterMembers.asym_id.value(j)
-                        const operList = clusterMembers.pdbx_struct_oper_list_ids.value(j)
-                        if (operList.length === 0) operList.push('1') // TODO hack assuming '1' is the id of the identity operator
-                        clusterByMember.set(clusterMemberKey(symmetry.assembly_id, asymId, operList), i)
-                    }
-                }
+    if (clusters?.length && ctx.structure) {
+        const clusterByMember = new Map<string, number>()
+        for (let i = 0, il = clusters.length; i < il; ++i) {
+            const { members } = clusters[i]!
+            for (let j = 0, jl = members.length; j < jl; ++j) {
+                const asymId = members[j]!.asym_id
+                const operList = [...members[j]!.pdbx_struct_oper_list_ids || []] as string[]
+                if (operList.length === 0) operList.push('1') // TODO hack assuming '1' is the id of the identity operator
+                clusterByMember.set(clusterMemberKey(asymId, operList), i)
+            }
+        }
 
-                const palette = getPalette(clusters._rowCount, props)
-                legend = palette.legend
+        const palette = getPalette(clusters.length, props)
+        legend = palette.legend
 
-                color = (location: Location): Color => {
-                    if (StructureElement.Location.is(location)) {
-                        const { assembly } = location.unit.conformation.operator
-                        if (assembly && assembly.id === symmetry.assembly_id) {
-                            const asymId = getAsymId(location.unit)(location)
-                            const cluster = clusterByMember.get(clusterMemberKey(assembly.id, asymId, assembly.operList))
-                            return cluster !== undefined ? palette.color(cluster) : DefaultColor
-                        }
-                    }
-                    return DefaultColor
-                }
+        color = (location: Location): Color => {
+            if (StructureElement.Location.is(location)) {
+                const { assembly } = location.unit.conformation.operator
+                const asymId = getAsymId(location.unit)(location)
+                const cluster = clusterByMember.get(clusterMemberKey(asymId, assembly.operList))
+                return cluster !== undefined ? palette.color(cluster) : DefaultColor
             }
+            return DefaultColor
         }
     }
 
@@ -93,6 +84,7 @@ export function AssemblySymmetryClusterColorTheme(ctx: ThemeDataContext, props:
         granularity: 'instance',
         color,
         props,
+        contextHash,
         description: 'Assigns chain colors according to assembly symmetry cluster membership.',
         legend
     }
@@ -103,5 +95,8 @@ export const AssemblySymmetryClusterColorThemeProvider: ColorTheme.Provider<Asse
     factory: AssemblySymmetryClusterColorTheme,
     getParams: getAssemblySymmetryClusterColorThemeParams,
     defaultValues: PD.getDefaultValues(AssemblySymmetryClusterColorThemeParams),
-    isApplicable: (ctx: ThemeDataContext) => !!ctx.structure && !ctx.structure.isEmpty && ctx.structure.models[0].customProperties.has(AssemblySymmetry.Descriptor)
+    isApplicable: (ctx: ThemeDataContext) => AssemblySymmetry.isApplicable(ctx.structure),
+    ensureCustomProperties: (ctx: CustomPropertyContext, data: ThemeDataContext) => {
+        return data.structure ? AssemblySymmetryProvider.attach(ctx, data.structure) : Promise.resolve()
+    }
 }

src/mol-model-props/rcsb/util.ts

@@ -1,31 +1,22 @@
 /**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import { Unit, Structure } from '../../mol-model/structure';
+import { Structure } from '../../mol-model/structure';
 import { ParamDefinition as PD } from '../../mol-util/param-definition'
-import { AssemblySymmetry } from './assembly-symmetry';
-
-export function getAssemblyIds(units: ReadonlyArray<Unit>) {
-    const ids = new Set<string>()
-    units.forEach(u => {
-        if (u.conformation.operator.assembly) ids.add(u.conformation.operator.assembly.id)
-    })
-    return Array.from(ids.values())
-}
+import {  AssemblySymmetryProvider } from './assembly-symmetry';
 
 export function getSymmetrySelectParam(structure?: Structure) {
-    const param = PD.Select<number>(-1, [[-1, 'No Symmetries']])
-    if (structure && structure.models[0].customProperties.has(AssemblySymmetry.Descriptor)) {
-        const assemblySymmetry = AssemblySymmetry.get(structure.models[0])!
-        const assemblyIds = getAssemblyIds(structure.units)
-        const s = assemblySymmetry.getSymmetries(assemblyIds)
-        if (s._rowCount) {
+    const param = PD.Select<number>(0, [[0, 'No Symmetries']])
+    if (structure) {
+        const assemblySymmetry = AssemblySymmetryProvider.getValue(structure).value
+        if (assemblySymmetry) {
             const options: [number, string][] = []
-            for (let i = 0, il = s._rowCount; i < il; ++i) {
-                options.push([ s.id.value(i), `${s.assembly_id.value(i)}: ${s.symbol.value(i)} ${s.kind.value(i)}` ])
+            for (let i = 0, il = assemblySymmetry.length; i < il; ++i) {
+                const { symbol, kind } = assemblySymmetry[i]
+                options.push([ i, `${i + 1}: ${symbol} ${kind}` ])
             }
             if (options.length) {
                 param.options = options

src/mol-plugin/behavior/dynamic/custom-props/rcsb/assembly-symmetry.ts

@@ -1,72 +1,105 @@
 /**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
 import { ParamDefinition as PD } from '../../../../../mol-util/param-definition'
-import { AssemblySymmetry } from '../../../../../mol-model-props/rcsb/assembly-symmetry';
-import { AssemblySymmetryClusterColorThemeProvider } from '../../../../../mol-model-props/rcsb/themes/assembly-symmetry-cluster';
-import { AssemblySymmetryAxesRepresentationProvider } from '../../../../../mol-model-props/rcsb/representations/assembly-symmetry-axes';
-import { Loci, isDataLoci } from '../../../../../mol-model/loci';
-import { OrderedSet } from '../../../../../mol-data/int';
-import { Table } from '../../../../../mol-data/db';
-import { CustomPropertyRegistry } from '../../../../../mol-model-props/common/custom-property-registry';
+import { AssemblySymmetryProvider, AssemblySymmetry } from '../../../../../mol-model-props/rcsb/assembly-symmetry';
 import { PluginBehavior } from '../../../behavior';
+import { OrderedSet } from '../../../../../mol-data/int';
+import { Loci } from '../../../../../mol-model/loci';
+import { getAssemblySymmetryAxesRepresentation, AssemblySymmetryAxesParams } from '../../../../../mol-model-props/rcsb/representations/assembly-symmetry-axes';
+import { AssemblySymmetryClusterColorThemeProvider } from '../../../../../mol-model-props/rcsb/themes/assembly-symmetry-cluster';
+import { PluginStateTransform, PluginStateObject } from '../../../../state/objects';
+import { Task } from '../../../../../mol-task';
+import { PluginSpec } from '../../../../spec';
+import { PluginContext } from '../../../../context';
+import { getSymmetrySelectParam } from '../../../../../mol-model-props/rcsb/util';
+import { StateTransformer } from '../../../../../mol-state';
 
 export const RCSBAssemblySymmetry = PluginBehavior.create<{ autoAttach: boolean }>({
     name: 'rcsb-assembly-symmetry-prop',
     category: 'custom-props',
     display: { name: 'RCSB Assembly Symmetry' },
     ctor: class extends PluginBehavior.Handler<{ autoAttach: boolean }> {
-        private attach = AssemblySymmetry.createAttachTask(this.ctx.fetch);
+        private provider = AssemblySymmetryProvider
 
-        private provider: CustomPropertyRegistry.ModelProvider = {
-            option: [AssemblySymmetry.Descriptor.name, 'RCSB Assembly Symmetry'],
-            descriptor: AssemblySymmetry.Descriptor,
-            defaultSelected: this.params.autoAttach,
-            attachableTo: () => true,
-            attach: this.attach
+        private label = (loci: Loci): string | undefined => {
+            if (AssemblySymmetry.isAxesLoci(loci)) {
+                const labels: string[] = []
+                OrderedSet.forEach(loci.indices, v => {
+                    const { kind, type } = loci.data[v]
+                    if (type && kind) {
+                        labels.push(`Axis of type ${type} for ${kind} symmetry`)
+                    }
+                })
+                return labels.length ? labels.join(', ') : undefined
+            }
+            return undefined
         }
 
         register(): void {
-            this.ctx.customModelProperties.register(this.provider);
-            this.ctx.lociLabels.addProvider(labelAssemblySymmetryAxes);
+            this.ctx.state.dataState.actions.add(PluginSpec.Action(AssemblySymmetryAxes3D).action)
+            this.ctx.customStructureProperties.register(this.provider, this.params.autoAttach);
             this.ctx.structureRepresentation.themeCtx.colorThemeRegistry.add('rcsb-assembly-symmetry-cluster', AssemblySymmetryClusterColorThemeProvider)
-            this.ctx.structureRepresentation.registry.add('rcsb-assembly-symmetry-axes', AssemblySymmetryAxesRepresentationProvider)
+            this.ctx.lociLabels.addProvider(this.label);
         }
 
         update(p: { autoAttach: boolean }) {
             let updated = this.params.autoAttach !== p.autoAttach
             this.params.autoAttach = p.autoAttach;
-            this.provider.defaultSelected = p.autoAttach;
+            this.ctx.customStructureProperties.setDefaultAutoAttach(this.provider.descriptor.name, this.params.autoAttach);
             return updated;
         }
 
         unregister() {
-            this.ctx.customModelProperties.unregister(AssemblySymmetry.Descriptor.name);
-            this.ctx.lociLabels.removeProvider(labelAssemblySymmetryAxes);
+            // TODO remove `AssemblySymmetryAxes3D` from `this.ctx.state.dataState.actions`
+            this.ctx.customStructureProperties.unregister(this.provider.descriptor.name);
             this.ctx.structureRepresentation.themeCtx.colorThemeRegistry.remove('rcsb-assembly-symmetry-cluster')
-            this.ctx.structureRepresentation.registry.remove('rcsb-assembly-symmetry-axes')
+            this.ctx.lociLabels.removeProvider(this.label);
         }
     },
     params: () => ({
-        autoAttach: PD.Boolean(false)
+        autoAttach: PD.Boolean(false),
+        serverUrl: PD.Text(AssemblySymmetry.DefaultServerUrl)
     })
 });
 
-function labelAssemblySymmetryAxes(loci: Loci): string | undefined {
-    if (isDataLoci(loci) && AssemblySymmetry.is(loci.data) && loci.tag === 'axes') {
-        const { rcsb_assembly_symmetry_axis: axis, rcsb_assembly_symmetry: sym } = loci.data.db
-        const labels: string[] = []
-        OrderedSet.forEach(loci.indices, v => {
-            const symmetryId = axis.symmetry_id.value(v)
-            const symmetry = Table.pickRow(sym, i => sym.id.value(i) === symmetryId)
-            if (symmetry) {
-                labels.push(`Axis of order ${axis.order.value(v)} for ${symmetry.kind} ${symmetry.type.toLowerCase()} symmetry`)
-            }
-        })
-        return labels.length ? labels.join(', ') : undefined
+type AssemblySymmetryAxes3D = typeof AssemblySymmetryAxes3D
+const AssemblySymmetryAxes3D = PluginStateTransform.BuiltIn({
+    name: 'rcsb-assembly-symmetry-axes-3d',
+    display: 'RCSB Assembly Symmetry Axes',
+    from: PluginStateObject.Molecule.Structure,
+    to: PluginStateObject.Shape.Representation3D,
+    params: (a, ctx: PluginContext) => {
+        console.log(a?.data, getSymmetrySelectParam(a?.data))
+        return {
+            ...AssemblySymmetryAxesParams,
+            symmetryIndex: getSymmetrySelectParam(a?.data),
+        }
+    }
+})({
+    canAutoUpdate({ oldParams, newParams }) {
+        return true;
+    },
+    apply({ a, params }, plugin: PluginContext) {
+        return Task.create('RCSB Assembly Symmetry Axes', async ctx => {
+            await AssemblySymmetryProvider.attach({ runtime: ctx, fetch: plugin.fetch }, a.data)
+            const repr = await getAssemblySymmetryAxesRepresentation(ctx, a.data, params)
+            const { symbol, kind } = AssemblySymmetryProvider.getValue(a.data).value![params.symmetryIndex]
+            return new PluginStateObject.Shape.Representation3D({ repr, source: a }, { label: `Axes`, description: `${symbol} ${kind}` });
+        });
+    },
+    update({ a, b, newParams }) {
+        return Task.create('RCSB Assembly Symmetry Axes', async ctx => {
+            await getAssemblySymmetryAxesRepresentation(ctx, a.data, newParams, b.data.repr);
+            const { symbol, kind } = AssemblySymmetryProvider.getValue(a.data).value![newParams.symmetryIndex]
+            b.description = `${symbol} ${kind}`
+            return StateTransformer.UpdateResult.Updated;
+        });
+    },
+    isApplicable(a) {
+        return AssemblySymmetry.isApplicable(a.data)
     }
-    return undefined
-}
+});

src/mol-plugin/index.ts

@@ -74,7 +74,7 @@ export const DefaultPluginSpec: PluginSpec = {
         PluginSpec.Behavior(PluginBehaviors.CustomProps.SecondaryStructure),
         PluginSpec.Behavior(PluginBehaviors.CustomProps.ValenceModel),
         PluginSpec.Behavior(PluginBehaviors.CustomProps.PDBeStructureQualityReport, { autoAttach: true, showTooltip: true }),
-        PluginSpec.Behavior(PluginBehaviors.CustomProps.RCSBAssemblySymmetry, { autoAttach: true }),
+        PluginSpec.Behavior(PluginBehaviors.CustomProps.RCSBAssemblySymmetry),
         PluginSpec.Behavior(StructureRepresentationInteraction)
     ],
     customParamEditors: [

src/mol-plugin/state/transforms/model.ts

@@ -737,11 +737,12 @@ const CustomStructureProperties = PluginStateTransform.BuiltIn({
     }
 });
 async function attachStructureProps(structure: Structure, ctx: PluginContext, taskCtx: RuntimeContext, params: PD.Values<PD.Params>) {
+    const propertyCtx = { runtime: taskCtx, fetch: ctx.fetch }
     for (const name of Object.keys(params)) {
         const property = ctx.customStructureProperties.get(name)
         const props = params[name as keyof typeof params]
         if (props.autoAttach) {
-            await property.attach(structure, props).runInContext(taskCtx)
+            await property.attach(propertyCtx, structure, props)
         } else {
             property.setProps(structure, props)
         }

src/mol-plugin/state/transforms/representation.ts

@@ -204,11 +204,12 @@ const StructureRepresentation3D = PluginStateTransform.BuiltIn({
     },
     apply({ a, params }, plugin: PluginContext) {
         return Task.create('Structure Representation', async ctx => {
+            const propertyCtx = { runtime: ctx, fetch: plugin.fetch }
             const provider = plugin.structureRepresentation.registry.get(params.type.name)
-            if (provider.ensureDependencies) await provider.ensureDependencies(a.data).runInContext(ctx)
+            if (provider.ensureCustomProperties) await provider.ensureCustomProperties(propertyCtx, a.data)
             const props = params.type.params || {}
             const repr = provider.factory({ webgl: plugin.canvas3d?.webgl, ...plugin.structureRepresentation.themeCtx }, provider.getParams)
-            await Theme.ensureDependencies(plugin.structureRepresentation.themeCtx, { structure: a.data }, params).runInContext(ctx)
+            await Theme.ensureDependencies(propertyCtx, plugin.structureRepresentation.themeCtx, { structure: a.data }, params)
             repr.setTheme(Theme.create(plugin.structureRepresentation.themeCtx, { structure: a.data }, params))
             // TODO set initial state, repr.setState({})
             await repr.createOrUpdate(props, a.data).runInContext(ctx);
@@ -218,10 +219,11 @@ const StructureRepresentation3D = PluginStateTransform.BuiltIn({
     update({ a, b, oldParams, newParams }, plugin: PluginContext) {
         return Task.create('Structure Representation', async ctx => {
             if (newParams.type.name !== oldParams.type.name) return StateTransformer.UpdateResult.Recreate;
+            const propertyCtx = { runtime: ctx, fetch: plugin.fetch }
             const provider = plugin.structureRepresentation.registry.get(newParams.type.name)
-            if (provider.ensureDependencies) await provider.ensureDependencies(a.data).runInContext(ctx)
+            if (provider.ensureCustomProperties) await provider.ensureCustomProperties(propertyCtx, a.data)
             const props = { ...b.data.repr.props, ...newParams.type.params }
-            await Theme.ensureDependencies(plugin.structureRepresentation.themeCtx, { structure: a.data }, newParams).runInContext(ctx)
+            await Theme.ensureDependencies(propertyCtx, plugin.structureRepresentation.themeCtx, { structure: a.data }, newParams)
             b.data.repr.setTheme(Theme.create(plugin.structureRepresentation.themeCtx, { structure: a.data }, newParams));
             await b.data.repr.createOrUpdate(props, a.data).runInContext(ctx);
             b.data.source = a
@@ -579,8 +581,9 @@ const VolumeRepresentation3D = PluginStateTransform.BuiltIn({
     },
     apply({ a, params }, plugin: PluginContext) {
         return Task.create('Volume Representation', async ctx => {
+            const propertyCtx = { runtime: ctx, fetch: plugin.fetch }
             const provider = plugin.volumeRepresentation.registry.get(params.type.name)
-            if (provider.ensureDependencies) await provider.ensureDependencies(a.data)
+            if (provider.ensureCustomProperties) await provider.ensureCustomProperties(propertyCtx, a.data)
             const props = params.type.params || {}
             const repr = provider.factory({ webgl: plugin.canvas3d?.webgl, ...plugin.volumeRepresentation.themeCtx }, provider.getParams)
             repr.setTheme(Theme.create(plugin.volumeRepresentation.themeCtx, { volume: a.data }, params))
@@ -657,7 +660,7 @@ const ModelUnitcell3D = PluginStateTransform.BuiltIn({
     },
     update({ a, b, newParams }) {
         return Task.create('Model Unitcell', async ctx => {
-            await getUnitcellRepresentation(ctx, a.data, newParams, b.data.repr as ShapeRepresentation<any, any, any>);
+            await getUnitcellRepresentation(ctx, a.data, newParams, b.data.repr);
             return StateTransformer.UpdateResult.Updated;
         });
     }

src/mol-repr/representation.ts

@@ -21,6 +21,7 @@ import { Mat4 } from '../mol-math/linear-algebra';
 import { getQualityProps } from './util';
 import { BaseGeometry } from '../mol-geo/geometry/base';
 import { Visual } from './visual';
+import { CustomPropertyContext } from '../mol-model-props/common/custom-property-registry';
 
 // export interface RepresentationProps {
 //     visuals?: string[]
@@ -47,7 +48,7 @@ export interface RepresentationProvider<D, P extends PD.Params, S extends Repres
     readonly defaultColorTheme: string
     readonly defaultSizeTheme: string
     readonly isApplicable: (data: D) => boolean
-    readonly ensureDependencies?: (data: D) => Task<void>
+    readonly ensureCustomProperties?: (ctx: CustomPropertyContext, data: D) => Promise<void>
 }
 
 export namespace RepresentationProvider {

src/mol-repr/structure/representation/cartoon.ts

@@ -16,6 +16,7 @@ import { PolymerDirectionParams, PolymerDirectionVisual } from '../visual/polyme
 import { PolymerGapParams, PolymerGapVisual } from '../visual/polymer-gap-cylinder';
 import { PolymerTraceParams, PolymerTraceVisual } from '../visual/polymer-trace-mesh';
 import { SecondaryStructureProvider } from '../../../mol-model-props/computed/secondary-structure';
+import { CustomPropertyContext } from '../../../mol-model-props/common/custom-property-registry';
 
 const CartoonVisuals = {
     'polymer-trace': (ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, PolymerTraceParams>) => UnitsRepresentation('Polymer trace mesh', ctx, getParams, PolymerTraceVisual),
@@ -63,7 +64,7 @@ export const CartoonRepresentationProvider: StructureRepresentationProvider<Cart
     defaultColorTheme: 'polymer-id',
     defaultSizeTheme: 'uniform',
     isApplicable: (structure: Structure) => structure.polymerResidueCount > 0,
-    ensureDependencies: (structure: Structure) => {
-        return SecondaryStructureProvider.attach(structure)
+    ensureCustomProperties: (ctx: CustomPropertyContext, structure: Structure) => {
+        return SecondaryStructureProvider.attach(ctx, structure)
     }
 }

src/mol-repr/structure/representation/interactions.ts

@@ -13,6 +13,7 @@ import { InteractionsIntraUnitParams, InteractionsIntraUnitVisual } from '../vis
 import { UnitKindOptions, UnitKind } from '../visual/util/common';
 import { InteractionsProvider } from '../../../mol-model-props/computed/interactions';
 import { InteractionsInterUnitParams, InteractionsInterUnitVisual } from '../visual/interactions-inter-unit-cylinder';
+import { CustomPropertyContext } from '../../../mol-model-props/common/custom-property-registry';
 
 const InteractionsVisuals = {
     'intra-unit': (ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, InteractionsIntraUnitParams>) => UnitsRepresentation('Intra-unit interactions cylinder', ctx, getParams, InteractionsIntraUnitVisual),
@@ -45,7 +46,7 @@ export const InteractionsRepresentationProvider: StructureRepresentationProvider
     defaultColorTheme: 'interaction-type',
     defaultSizeTheme: 'uniform',
     isApplicable: (structure: Structure) => structure.elementCount > 0,
-    ensureDependencies: (structure: Structure) => {
-        return InteractionsProvider.attach(structure)
+    ensureCustomProperties: (ctx: CustomPropertyContext, structure: Structure) => {
+        return InteractionsProvider.attach(ctx, structure)
     }
 }

src/mol-theme/color/accessible-surface-area.ts

@@ -13,8 +13,8 @@ import { Unit, StructureElement, StructureProperties } from '../../mol-model/str
 import { Location } from '../../mol-model/location';
 import { AccessibleSurfaceAreaProvider } from '../../mol-model-props/computed/accessible-surface-area';
 import { ColorListName, ColorListOptionsScale } from '../../mol-util/color/lists';
-import { Task } from '../../mol-task';
 import { AccessibleSurfaceArea } from '../../mol-model-props/computed/accessible-surface-area/shrake-rupley';
+import { CustomPropertyContext } from '../../mol-model-props/common/custom-property-registry';
 
 const DefaultColor = Color(0xFAFAFA)
 const Description = 'Assigns a color based on the relative accessible surface area of a residue.'
@@ -40,7 +40,7 @@ export function AccessibleSurfaceAreaColorTheme(ctx: ThemeDataContext, props: PD
     const accessibleSurfaceArea = ctx.structure && AccessibleSurfaceAreaProvider.getValue(ctx.structure)
     const contextHash = accessibleSurfaceArea?.version
 
-    if (accessibleSurfaceArea && accessibleSurfaceArea.value && ctx.structure) {
+    if (accessibleSurfaceArea?.value && ctx.structure) {
         const { getSerialIndex } = ctx.structure.root.serialMapping
         const { area, serialResidueIndex } = accessibleSurfaceArea.value
 
@@ -72,7 +72,7 @@ export const AccessibleSurfaceAreaColorThemeProvider: ColorTheme.Provider<Access
     getParams: getAccessibleSurfaceAreaColorThemeParams,
     defaultValues: PD.getDefaultValues(AccessibleSurfaceAreaColorThemeParams),
     isApplicable: (ctx: ThemeDataContext) => !!ctx.structure,
-    ensureDependencies: (ctx: ThemeDataContext) => {
-        return ctx.structure ? AccessibleSurfaceAreaProvider.attach(ctx.structure) : Task.empty()
+    ensureCustomProperties: (ctx: CustomPropertyContext, data: ThemeDataContext) => {
+        return data.structure ? AccessibleSurfaceAreaProvider.attach(ctx, data.structure) : Promise.resolve()
     }
 }

src/mol-theme/color/interaction-type.ts

@@ -12,8 +12,8 @@ import { ThemeDataContext } from '../theme';
 import { ColorTheme, LocationColor } from '../color';
 import { InteractionType } from '../../mol-model-props/computed/interactions/common';
 import { TableLegend } from '../../mol-util/legend';
-import { Task } from '../../mol-task';
 import { Interactions } from '../../mol-model-props/computed/interactions/interactions';
+import { CustomPropertyContext } from '../../mol-model-props/common/custom-property-registry';
 
 const DefaultColor = Color(0xCCCCCC)
 const Description = 'Assigns colors according the interaction type of a link.'
@@ -111,7 +111,7 @@ export const InteractionTypeColorThemeProvider: ColorTheme.Provider<InteractionT
     getParams: getInteractionTypeColorThemeParams,
     defaultValues: PD.getDefaultValues(InteractionTypeColorThemeParams),
     isApplicable: (ctx: ThemeDataContext) => !!ctx.structure,
-    ensureDependencies: (ctx: ThemeDataContext) => {
-        return ctx.structure ? InteractionsProvider.attach(ctx.structure) : Task.empty()
+    ensureCustomProperties: (ctx: CustomPropertyContext, data: ThemeDataContext) => {
+        return data.structure ? InteractionsProvider.attach(ctx, data.structure) : Promise.resolve()
     }
 }

src/mol-theme/color/secondary-structure.ts

@@ -15,7 +15,7 @@ import { ThemeDataContext } from '../theme';
 import { TableLegend } from '../../mol-util/legend';
 import { SecondaryStructureProvider, SecondaryStructureValue } from '../../mol-model-props/computed/secondary-structure';
 import { getAdjustedColorMap } from '../../mol-util/color/color';
-import { Task } from '../../mol-task';
+import { CustomPropertyContext } from '../../mol-model-props/common/custom-property-registry';
 
 // from Jmol http://jmol.sourceforge.net/jscolors/ (shapely)
 const SecondaryStructureColors = ColorMap({
@@ -117,7 +117,7 @@ export const SecondaryStructureColorThemeProvider: ColorTheme.Provider<Secondary
     getParams: getSecondaryStructureColorThemeParams,
     defaultValues: PD.getDefaultValues(SecondaryStructureColorThemeParams),
     isApplicable: (ctx: ThemeDataContext) => !!ctx.structure,
-    ensureDependencies: (ctx: ThemeDataContext) => {
-        return ctx.structure ? SecondaryStructureProvider.attach(ctx.structure) : Task.empty()
+    ensureCustomProperties: (ctx: CustomPropertyContext, data: ThemeDataContext) => {
+        return data.structure ? SecondaryStructureProvider.attach(ctx, data.structure) : Promise.resolve()
     }
 }

src/mol-theme/theme.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -10,7 +10,7 @@ import { Structure } from '../mol-model/structure';
 import { VolumeData } from '../mol-model/volume';
 import { ParamDefinition as PD } from '../mol-util/param-definition';
 import { Shape } from '../mol-model/shape';
-import { Task } from '../mol-task';
+import { CustomPropertyContext } from '../mol-model-props/common/custom-property-registry';
 
 export interface ThemeRegistryContext {
     colorThemeRegistry: ColorTheme.Registry
@@ -51,11 +51,9 @@ namespace Theme {
         return { color: ColorTheme.Empty, size: SizeTheme.Empty }
     }
 
-    export function ensureDependencies(ctx: ThemeRegistryContext, data: ThemeDataContext, props: Props) {
-        return Task.create(`Theme dependencies`, async runtime => {
-            await ctx.colorThemeRegistry.get(props.colorTheme.name).ensureDependencies?.(data).runInContext(runtime)
-            await ctx.sizeThemeRegistry.get(props.sizeTheme.name).ensureDependencies?.(data).runInContext(runtime)
-        })
+    export async function ensureDependencies(ctx: CustomPropertyContext, theme: ThemeRegistryContext, data: ThemeDataContext, props: Props) {
+        await theme.colorThemeRegistry.get(props.colorTheme.name).ensureCustomProperties?.(ctx, data)
+        await theme.sizeThemeRegistry.get(props.sizeTheme.name).ensureCustomProperties?.(ctx, data)
     }
 }
 
@@ -67,7 +65,7 @@ export interface ThemeProvider<T extends ColorTheme<P> | SizeTheme<P>, P extends
     readonly getParams: (ctx: ThemeDataContext) => P
     readonly defaultValues: PD.Values<P>
     readonly isApplicable: (ctx: ThemeDataContext) => boolean
-    readonly ensureDependencies?: (ctx: ThemeDataContext) => Task<void>
+    readonly ensureCustomProperties?: (ctx: CustomPropertyContext, data: ThemeDataContext) => Promise<void>
 }
 
 function getTypes(list: { name: string, provider: ThemeProvider<any, any> }[]) {

src/servers/model/properties/providers/rcsb.ts

@@ -1,23 +0,0 @@
-/**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import { AssemblySymmetry } from '../../../../mol-model-props/rcsb/assembly-symmetry';
-import { AttachModelProperty } from '../../property-provider';
-import { ajaxGet } from '../../../../mol-util/data-source';
-import { GraphQLClient } from '../../../../mol-util/graphql-client';
-import { getParam } from '../../../common/util';
-
-export const RCSB_assemblySymmetry: AttachModelProperty = ({ model, params }) => {
-    const url = getApiUrl(params, 'assembly_symmetry', `https:${AssemblySymmetry.GraphQLEndpointURL}`)
-    const client = new GraphQLClient(url, ajaxGet)
-    return AssemblySymmetry.attachFromCifOrAPI(model, client)
-}
-
-function getApiUrl(params: any, name: string, fallback: string) {
-    const path = getParam<string>(params, 'RCSB', 'API', name);
-    if (!path) return fallback;
-    return path;
-}

src/servers/model/properties/rcsb.ts

@@ -1,17 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-import { AttachModelProperties } from '../property-provider';
-import { RCSB_assemblySymmetry } from './providers/rcsb';
-
-export const attachModelProperties: AttachModelProperties = (args) => {
-    // return a list of promises that start attaching the props in parallel
-    // (if there are downloads etc.)
-    return [
-        RCSB_assemblySymmetry(args)
-    ];
-}

src/servers/model/property-provider.ts

@@ -11,12 +11,10 @@ import { ConsoleLogger } from '../../mol-util/console-logger';
 
 // TODO enable dynamic imports again
 import * as pdbeProps from './properties/pdbe'
-import * as rcsbProps from './properties/rcsb'
 import * as wwpdbProps from './properties/wwpdb'
 
 const attachModelProperties: { [k: string]: AttachModelProperties } = {
     pdbe: pdbeProps.attachModelProperties,
-    rcsb: rcsbProps.attachModelProperties,
     wwpdb: wwpdbProps.attachModelProperties
 }
 

src/tests/browser/render-structure.ts

@@ -24,6 +24,8 @@ import { lociLabel } from '../../mol-theme/label';
 import { InteractionsRepresentationProvider } from '../../mol-repr/structure/representation/interactions';
 import { InteractionsProvider } from '../../mol-model-props/computed/interactions';
 import { SecondaryStructureProvider } from '../../mol-model-props/computed/secondary-structure';
+import { SyncRuntimeContext } from '../../mol-task/execution/synchronous';
+import { ajaxGet } from '../../mol-util/data-source';
 
 const parent = document.getElementById('app')!
 parent.style.width = '100%'
@@ -115,15 +117,18 @@ function getGaussianSurfaceRepr() {
 }
 
 async function init() {
+    const ctx = { runtime: SyncRuntimeContext, fetch: ajaxGet }
+
     const cif = await downloadFromPdb('3pqr')
     const models = await getModels(cif)
     const structure = await getStructure(models[0])
+
     console.time('compute SecondaryStructure')
-    await SecondaryStructureProvider.attach(structure).run()
+    await SecondaryStructureProvider.attach(ctx, structure)
     console.timeEnd('compute SecondaryStructure');
 
     console.time('compute Interactions')
-    await InteractionsProvider.attach(structure).run()
+    await InteractionsProvider.attach(ctx, structure)
     console.timeEnd('compute Interactions');
     console.log(InteractionsProvider.getValue(structure).value)