diff --git a/src/mol-model-props/common/custom-property-registry.ts b/src/mol-model-props/common/custom-property-registry.ts
index 4611cd89ebcd740a4c17386b8f436d88625f8108..54e8f1470abaa91be6c91801ad9f91295fc8d727 100644
--- a/src/mol-model-props/common/custom-property-registry.ts
+++ b/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)
diff --git a/src/mol-model-props/computed/accessible-surface-area.ts b/src/mol-model-props/computed/accessible-surface-area.ts
index ca6187116644d96aca965dee5181d4bb79ca920e..0352bf3fd26f8fa662971ac620a9977f34104d44 100644
--- a/src/mol-model-props/computed/accessible-surface-area.ts
+++ b/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)
}
})
\ No newline at end of file
diff --git a/src/mol-model-props/computed/interactions.ts b/src/mol-model-props/computed/interactions.ts
index 841a11741b1ece7f1856e25060af0328a4662437..49b64a9b52e59dc4ec8a3bcaf159e7630c118b14 100644
--- a/src/mol-model-props/computed/interactions.ts
+++ b/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)
}
diff --git a/src/mol-model-props/computed/interactions/interactions.ts b/src/mol-model-props/computed/interactions/interactions.ts
index a71ef972027cd9b6d588557ae6690c7b64bc6f5f..4b5a612b0ef9362bacb1993f080e8a51d78725f0 100644
--- a/src/mol-model-props/computed/interactions/interactions.ts
+++ b/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)
diff --git a/src/mol-model-props/computed/secondary-structure.ts b/src/mol-model-props/computed/secondary-structure.ts
index 70bd44db607ae48e8bf034ab04fd0e64e7e033ac..fd9c36e76e179590a110761e2417537a0bad32c9 100644
--- a/src/mol-model-props/computed/secondary-structure.ts
+++ b/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)
diff --git a/src/mol-model-props/computed/valence-model.ts b/src/mol-model-props/computed/valence-model.ts
index e99c91ee3b239d1b9fd1ef13f5fe0c2633da1ea8..82e1e0d306ece1705ae9ca79294288d8624c552c 100644
--- a/src/mol-model-props/computed/valence-model.ts
+++ b/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)
}
})
\ No newline at end of file
diff --git a/src/mol-model-props/rcsb/assembly-symmetry.ts b/src/mol-model-props/rcsb/assembly-symmetry.ts
index d87065908d586257784f9f29439ffe975144661c..90fa3e927f84d531677f2320ec8c1f819edcd713 100644
--- a/src/mol-model-props/rcsb/assembly-symmetry.ts
+++ b/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)
}
-}
\ No newline at end of file
+})
\ No newline at end of file
diff --git a/src/mol-model-props/rcsb/graphql/symmetry.gql.ts b/src/mol-model-props/rcsb/graphql/symmetry.gql.ts
index 91395a77be0e771b4f1bddfbee1e9353aeba71e4..7980557163cf18d2b970be0ab0ceec172273e6ac 100644
--- a/src/mol-model-props/rcsb/graphql/symmetry.gql.ts
+++ b/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
}
}
-}`
\ No newline at end of file
+}
+`
\ No newline at end of file
diff --git a/src/mol-model-props/rcsb/graphql/types.d.ts b/src/mol-model-props/rcsb/graphql/types.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a5b8734ac4fb192bd0ab1827c2f631695aefa3b1
--- /dev/null
+++ b/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'>
+ )>>> }
+ )>>> }
+ )> }
+);
diff --git a/src/mol-model-props/rcsb/graphql/types.ts b/src/mol-model-props/rcsb/graphql/types.ts
deleted file mode 100644
index dc12d2cf5b74a89f3c91506dba1f6df786386029..0000000000000000000000000000000000000000
--- a/src/mol-model-props/rcsb/graphql/types.ts
+++ /dev/null
@@ -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>;
- };
-}
diff --git a/src/mol-model-props/rcsb/representations/assembly-symmetry-axes.ts b/src/mol-model-props/rcsb/representations/assembly-symmetry-axes.ts
index 9f716ffd8e03fdbf3ed9aedfb3f116122f3ae14d..53547843ea481aa7fb9a4ffeb62e5dcbd7d8ef44 100644
--- a/src/mol-model-props/rcsb/representations/assembly-symmetry-axes.ts
+++ b/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)
}
\ No newline at end of file
diff --git a/src/mol-model-props/rcsb/themes/assembly-symmetry-cluster.ts b/src/mol-model-props/rcsb/themes/assembly-symmetry-cluster.ts
index 50215e718df8b8fe29a44b5f1b38d580378ccf21..bfd106f684c9d780d14cc68168951706b8c2d8d4 100644
--- a/src/mol-model-props/rcsb/themes/assembly-symmetry-cluster.ts
+++ b/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()
+ }
}
\ No newline at end of file
diff --git a/src/mol-model-props/rcsb/util.ts b/src/mol-model-props/rcsb/util.ts
index 86b5855fd8317750aff6fef4ca91d8a54b4c3093..dd1ac42375369752eb19f1fa892d7eb90d361151 100644
--- a/src/mol-model-props/rcsb/util.ts
+++ b/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
diff --git a/src/mol-plugin/behavior/dynamic/custom-props/rcsb/assembly-symmetry.ts b/src/mol-plugin/behavior/dynamic/custom-props/rcsb/assembly-symmetry.ts
index 5e1b21231883d1880f390af42df7a56f16badced..04eeb979641603911183fcf5c19fbc904ba0b994 100644
--- a/src/mol-plugin/behavior/dynamic/custom-props/rcsb/assembly-symmetry.ts
+++ b/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
-}
\ No newline at end of file
+});
\ No newline at end of file
diff --git a/src/mol-plugin/index.ts b/src/mol-plugin/index.ts
index 732cb6917626421f05703761eac5eb08539c10fe..034ac329454d4c1e211685d7190501e194674127 100644
--- a/src/mol-plugin/index.ts
+++ b/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: [
diff --git a/src/mol-plugin/state/transforms/model.ts b/src/mol-plugin/state/transforms/model.ts
index 5b449c21ad7fdbc966ad573c3ebafdf02f1d615c..546a9168d1f5e7ee977ab977cc39caf9ee59b458 100644
--- a/src/mol-plugin/state/transforms/model.ts
+++ b/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)
}
diff --git a/src/mol-plugin/state/transforms/representation.ts b/src/mol-plugin/state/transforms/representation.ts
index bc8cb30580eb647975e975e21a670d9be4be1e19..8b1ddab5f8df593a55d32aae3ffb005ecad6c6a0 100644
--- a/src/mol-plugin/state/transforms/representation.ts
+++ b/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;
});
}
diff --git a/src/mol-repr/representation.ts b/src/mol-repr/representation.ts
index 2abfa6119d988e118f25654d8cb2435ff1c9b2df..c3578edce242082a3a3c07e3ab671764f933079e 100644
--- a/src/mol-repr/representation.ts
+++ b/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 {
diff --git a/src/mol-repr/structure/representation/cartoon.ts b/src/mol-repr/structure/representation/cartoon.ts
index 70cbad54d8c8e998006ccc2014a250923ec680ed..fa6c541499b77e6552dda5003061d66ab5865ec7 100644
--- a/src/mol-repr/structure/representation/cartoon.ts
+++ b/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)
}
}
\ No newline at end of file
diff --git a/src/mol-repr/structure/representation/interactions.ts b/src/mol-repr/structure/representation/interactions.ts
index d29fdd9b4e5f16e825ee543f75186077b4c65f00..d9aa4d4c2be49f7ad4c6b34ea7b2f76174eb3c6c 100644
--- a/src/mol-repr/structure/representation/interactions.ts
+++ b/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)
}
}
\ No newline at end of file
diff --git a/src/mol-theme/color/accessible-surface-area.ts b/src/mol-theme/color/accessible-surface-area.ts
index 951c325b60f6fa706ee56b0ac988e2781bebe402..fd4d1042e6154cd163011996f0b12e681f6992fc 100644
--- a/src/mol-theme/color/accessible-surface-area.ts
+++ b/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()
}
}
\ No newline at end of file
diff --git a/src/mol-theme/color/interaction-type.ts b/src/mol-theme/color/interaction-type.ts
index d83fa6e872305e9444552d0e2b29be06746d9efe..bb8c055b699adaa056ddd093dc49584c74140eb3 100644
--- a/src/mol-theme/color/interaction-type.ts
+++ b/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()
}
}
\ No newline at end of file
diff --git a/src/mol-theme/color/secondary-structure.ts b/src/mol-theme/color/secondary-structure.ts
index 2af2a6b3e58dfefd03151f54d2a38ec163f582ee..be8c1dce2b0c1bb5295804d3925beadd918f0472 100644
--- a/src/mol-theme/color/secondary-structure.ts
+++ b/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()
}
}
\ No newline at end of file
diff --git a/src/mol-theme/theme.ts b/src/mol-theme/theme.ts
index d1b0d5fe7b2bc99e031dbbe2978d22692cca6100..a59d7ec8ef861ad58041dccd758404c41cf3997d 100644
--- a/src/mol-theme/theme.ts
+++ b/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> }[]) {
diff --git a/src/servers/model/properties/providers/rcsb.ts b/src/servers/model/properties/providers/rcsb.ts
deleted file mode 100644
index 011ad4b3cb367457b2c749e723628be487509c76..0000000000000000000000000000000000000000
--- a/src/servers/model/properties/providers/rcsb.ts
+++ /dev/null
@@ -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;
-}
\ No newline at end of file
diff --git a/src/servers/model/properties/rcsb.ts b/src/servers/model/properties/rcsb.ts
deleted file mode 100644
index dbb6b554283fe24a126420dcd2c819d334240cca..0000000000000000000000000000000000000000
--- a/src/servers/model/properties/rcsb.ts
+++ /dev/null
@@ -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)
- ];
-}
\ No newline at end of file
diff --git a/src/servers/model/property-provider.ts b/src/servers/model/property-provider.ts
index 20c1754105d04500f01c79daf11c2d11302f6686..92c5eb63798fa2c4177d8500d9da9d693ccc9f58 100644
--- a/src/servers/model/property-provider.ts
+++ b/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
}
diff --git a/src/tests/browser/render-structure.ts b/src/tests/browser/render-structure.ts
index d339c38b63664b1f35352598f4b598709683fc03..b4a150713367fc41078d1bb54cc40b3227fb3968 100644
--- a/src/tests/browser/render-structure.ts
+++ b/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)