boltz-api 0.30.3

package/resources/small-molecule/library-screen.d.ts

@@ -0,0 +1,3494 @@
+import { APIResource } from "../../core/resource.js";
+import { APIPromise } from "../../core/api-promise.js";
+import { CursorPage, type CursorPageParams, PagePromise } from "../../core/pagination.js";
+import { RequestOptions } from "../../internal/request-options.js";
+/**
+ * Screen an existing library of small molecules against a protein target. Results are scored by binding confidence (likelihood of binding, for hit discovery), optimization score (binding strength ranking, for lead optimization), and structure confidence.
+ */
+export declare class LibraryScreen extends APIResource {
+    /**
+     * Retrieve a library screen by ID, including progress and status
+     *
+     * @example
+     * ```ts
+     * const libraryScreen =
+     *   await client.smallMolecule.libraryScreen.retrieve('id');
+     * ```
+     */
+    retrieve(id: string, query?: LibraryScreenRetrieveParams | null | undefined, options?: RequestOptions): APIPromise<LibraryScreenRetrieveResponse>;
+    /**
+     * List small molecule library screens, optionally filtered by workspace
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const libraryScreenListResponse of client.smallMolecule.libraryScreen.list()) {
+     *   // ...
+     * }
+     * ```
+     */
+    list(query?: LibraryScreenListParams | null | undefined, options?: RequestOptions): PagePromise<LibraryScreenListResponsesCursorPage, LibraryScreenListResponse>;
+    /**
+     * Permanently delete the input, output, and result data associated with this
+     * library screen. The library screen record itself is retained with a
+     * `data_deleted_at` timestamp. This action is irreversible.
+     *
+     * @example
+     * ```ts
+     * const response =
+     *   await client.smallMolecule.libraryScreen.deleteData('id');
+     * ```
+     */
+    deleteData(id: string, options?: RequestOptions): APIPromise<LibraryScreenDeleteDataResponse>;
+    /**
+     * Estimate the cost of a small molecule library screen without creating any
+     * resource or consuming GPU.
+     *
+     * @example
+     * ```ts
+     * const response =
+     *   await client.smallMolecule.libraryScreen.estimateCost({
+     *     molecules: [{ smiles: 'smiles' }],
+     *     target: {
+     *       entities: [
+     *         {
+     *           chain_ids: ['string'],
+     *           type: 'protein',
+     *           value: 'value',
+     *         },
+     *       ],
+     *     },
+     *   });
+     * ```
+     */
+    estimateCost(body: LibraryScreenEstimateCostParams, options?: RequestOptions): APIPromise<LibraryScreenEstimateCostResponse>;
+    /**
+     * Retrieve paginated results from a library screen
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const libraryScreenListResultsResponse of client.smallMolecule.libraryScreen.listResults(
+     *   'id',
+     * )) {
+     *   // ...
+     * }
+     * ```
+     */
+    listResults(id: string, query?: LibraryScreenListResultsParams | null | undefined, options?: RequestOptions): PagePromise<LibraryScreenListResultsResponsesCursorPage, LibraryScreenListResultsResponse>;
+    /**
+     * Screen a set of small molecule candidates against a protein target
+     *
+     * @example
+     * ```ts
+     * const response =
+     *   await client.smallMolecule.libraryScreen.start({
+     *     molecules: [{ smiles: 'smiles' }],
+     *     target: {
+     *       entities: [
+     *         {
+     *           chain_ids: ['string'],
+     *           type: 'protein',
+     *           value: 'value',
+     *         },
+     *       ],
+     *     },
+     *   });
+     * ```
+     */
+    start(body: LibraryScreenStartParams, options?: RequestOptions): APIPromise<LibraryScreenStartResponse>;
+    /**
+     * Stop an in-progress library screen early
+     *
+     * @example
+     * ```ts
+     * const response =
+     *   await client.smallMolecule.libraryScreen.stop('id');
+     * ```
+     */
+    stop(id: string, options?: RequestOptions): APIPromise<LibraryScreenStopResponse>;
+}
+export type LibraryScreenListResponsesCursorPage = CursorPage<LibraryScreenListResponse>;
+export type LibraryScreenListResultsResponsesCursorPage = CursorPage<LibraryScreenListResultsResponse>;
+/**
+ * A small molecule library screening engine run
+ */
+export interface LibraryScreenRetrieveResponse {
+    /**
+     * Unique SmScreen identifier
+     */
+    id: string;
+    completed_at: string | null;
+    created_at: string;
+    /**
+     * When the input, output, and result data was permanently deleted. Null if data
+     * has not been deleted.
+     */
+    data_deleted_at: string | null;
+    /**
+     * Engine used for small molecule library screen
+     */
+    engine: 'boltz-sm-screen';
+    /**
+     * Engine version used for small molecule library screen
+     */
+    engine_version: string;
+    error: LibraryScreenRetrieveResponse.Error | null;
+    /**
+     * Pipeline input (null if data deleted)
+     */
+    input: LibraryScreenRetrieveResponse.Input | null;
+    /**
+     * Whether this resource was created with a live API key.
+     */
+    livemode: boolean;
+    progress: LibraryScreenRetrieveResponse.Progress | null;
+    started_at: string | null;
+    status: 'pending' | 'running' | 'succeeded' | 'failed' | 'stopped';
+    stopped_at: string | null;
+    /**
+     * Workspace ID
+     */
+    workspace_id: string;
+    /**
+     * Client-provided idempotency key
+     */
+    idempotency_key?: string;
+}
+export declare namespace LibraryScreenRetrieveResponse {
+    interface Error {
+        /**
+         * Machine-readable error code
+         */
+        code: string;
+        /**
+         * Human-readable error message
+         */
+        message: string;
+        /**
+         * Additional field-level error details keyed by input path, when available.
+         */
+        details?: unknown;
+    }
+    /**
+     * Pipeline input (null if data deleted)
+     */
+    interface Input {
+        molecules: Input.Molecules;
+        /**
+         * Target protein with binding pocket for small molecule design or screening
+         */
+        target: Input.Target;
+        /**
+         * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+         * and custom filters.
+         */
+        molecule_filters?: Input.MoleculeFilters;
+    }
+    namespace Input {
+        interface Molecules {
+            /**
+             * URL to download the file
+             */
+            url: string;
+            /**
+             * When the presigned URL expires
+             */
+            url_expires_at: string;
+        }
+        /**
+         * Target protein with binding pocket for small molecule design or screening
+         */
+        interface Target {
+            /**
+             * Protein entities defining the target structure. Each entity represents a protein
+             * chain.
+             */
+            entities: Array<Target.Entity>;
+            /**
+             * Covalent bond constraints between atoms in the target complex. Atom-level ligand
+             * references currently support ligand_ccd only; ligand_smiles is unsupported.
+             */
+            bonds?: Array<Target.Bond>;
+            /**
+             * Structural constraints (pocket and contact). Atom-level ligand references
+             * currently support ligand_ccd only; ligand_smiles is unsupported.
+             */
+            constraints?: Array<Target.PocketConstraintResponse | Target.ContactConstraintResponse>;
+            /**
+             * Binding pocket residues, keyed by chain ID. Each key is a chain ID (e.g. "A")
+             * and the value is an array of 0-indexed residue indices that define the binding
+             * pocket on that chain. When provided, these residues guide pocket extraction and
+             * add a derived pocket constraint during affinity predictions. That derived
+             * constraint remains separate from any explicit pocket constraints in
+             * target.constraints. When omitted, the model auto-detects the pocket.
+             */
+            pocket_residues?: {
+                [key: string]: Array<number>;
+            };
+            /**
+             * Reference ligands as SMILES strings that help the model identify the binding
+             * pocket. When omitted, a set of drug-like default ligands is used for pocket
+             * detection.
+             */
+            reference_ligands?: Array<string>;
+        }
+        namespace Target {
+            interface Entity {
+                /**
+                 * Chain IDs for this entity
+                 */
+                chain_ids: Array<string>;
+                type: 'protein';
+                /**
+                 * Amino acid sequence (one-letter codes)
+                 */
+                value: string;
+                /**
+                 * Whether the sequence is cyclic
+                 */
+                cyclic?: boolean;
+                /**
+                 * Post-translational modifications. Optional; defaults to an empty list when
+                 * omitted.
+                 */
+                modifications?: Array<Entity.CcdModificationResponse | Entity.SmilesModificationResponse>;
+            }
+            namespace Entity {
+                interface CcdModificationResponse {
+                    /**
+                     * 0-based index of the residue to modify
+                     */
+                    residue_index: number;
+                    type: 'ccd';
+                    /**
+                     * CCD code from RCSB PDB (e.g. 'MSE' for selenomethionine, 'SEP' for
+                     * phosphoserine)
+                     */
+                    value: string;
+                }
+                interface SmilesModificationResponse {
+                    /**
+                     * 0-based index of the residue to modify
+                     */
+                    residue_index: number;
+                    type: 'smiles';
+                    /**
+                     * SMILES string for the modification
+                     */
+                    value: string;
+                }
+            }
+            /**
+             * Bond between two atoms. Atom-level ligand references currently support
+             * ligand_ccd entities only; ligand_smiles is unsupported.
+             */
+            interface Bond {
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                atom1: Bond.LigandAtomResponse | Bond.PolymerAtomResponse;
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                atom2: Bond.LigandAtomResponse | Bond.PolymerAtomResponse;
+            }
+            namespace Bond {
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                     * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    type: 'ligand_atom';
+                }
+                interface PolymerAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB)
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_atom';
+                }
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                     * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    type: 'ligand_atom';
+                }
+                interface PolymerAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB)
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_atom';
+                }
+            }
+            /**
+             * Constrains the binder to interact with specific pocket residues on the target.
+             */
+            interface PocketConstraintResponse {
+                /**
+                 * Chain ID of the binder molecule
+                 */
+                binder_chain_id: string;
+                /**
+                 * Binding pocket residues keyed by chain ID. Each key is a chain ID (e.g. "A") and
+                 * the value is an array of 0-indexed residue indices that define the pocket on
+                 * that chain.
+                 */
+                contact_residues: {
+                    [key: string]: Array<number>;
+                };
+                /**
+                 * Maximum allowed distance in Angstroms between binder and pocket residues.
+                 * Typical range: 4-8 A.
+                 */
+                max_distance_angstrom: number;
+                type: 'pocket';
+                /**
+                 * Whether to force the constraint
+                 */
+                force?: boolean;
+            }
+            /**
+             * Contact constraint between two tokens. Atom-level ligand references currently
+             * support ligand_ccd entities only; ligand_smiles is unsupported.
+             */
+            interface ContactConstraintResponse {
+                /**
+                 * Maximum distance in Angstroms
+                 */
+                max_distance_angstrom: number;
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                token1: ContactConstraintResponse.PolymerContactTokenResponse | ContactConstraintResponse.LigandContactTokenResponse;
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                token2: ContactConstraintResponse.PolymerContactTokenResponse | ContactConstraintResponse.LigandContactTokenResponse;
+                type: 'contact';
+                /**
+                 * Whether to force the constraint
+                 */
+                force?: boolean;
+            }
+            namespace ContactConstraintResponse {
+                interface PolymerContactTokenResponse {
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_contact';
+                }
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandContactTokenResponse {
+                    /**
+                     * Atom name. Atom-level references to ligand_smiles entities are currently
+                     * unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    type: 'ligand_contact';
+                }
+                interface PolymerContactTokenResponse {
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_contact';
+                }
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandContactTokenResponse {
+                    /**
+                     * Atom name. Atom-level references to ligand_smiles entities are currently
+                     * unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    type: 'ligand_contact';
+                }
+            }
+        }
+        /**
+         * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+         * and custom filters.
+         */
+        interface MoleculeFilters {
+            /**
+             * Controls the stringency of Boltz's built-in SMARTS structural alert filtering,
+             * which removes molecules matching known problematic substructures. 'recommended'
+             * (default): applies a curated set of alerts balancing safety and hit rate.
+             * 'extra': adds additional alerts beyond the recommended set for stricter
+             * filtering. 'aggressive': applies the most comprehensive alert set — may reject
+             * viable molecules. 'disabled': turns off Boltz SMARTS filtering entirely; only
+             * custom_filters will be applied.
+             */
+            boltz_smarts_catalog_filter_level?: 'recommended' | 'extra' | 'aggressive' | 'disabled';
+            /**
+             * Custom filters to apply. Molecules must pass all filters (AND logic).
+             */
+            custom_filters?: Array<MoleculeFilters.LipinskiFilterResponse | MoleculeFilters.RdkitDescriptorFilterResponse | MoleculeFilters.SmartsCustomFilterResponse | MoleculeFilters.SmartsCatalogFilterResponse | MoleculeFilters.SmilesRegexFilterResponse>;
+        }
+        namespace MoleculeFilters {
+            /**
+             * Lipinski's Rule of Five filter. Rejects molecules that violate drug-likeness
+             * criteria based on molecular weight, LogP, hydrogen bond donors, and hydrogen
+             * bond acceptors.
+             */
+            interface LipinskiFilterResponse {
+                /**
+                 * Maximum number of hydrogen bond acceptors. Lipinski threshold: 10
+                 */
+                max_hba: number;
+                /**
+                 * Maximum number of hydrogen bond donors. Lipinski threshold: 5
+                 */
+                max_hbd: number;
+                /**
+                 * Maximum LogP. Lipinski threshold: 5
+                 */
+                max_logp: number;
+                /**
+                 * Maximum molecular weight (Da). Lipinski threshold: 500
+                 */
+                max_mw: number;
+                type: 'lipinski_filter';
+                /**
+                 * If true, one rule violation is allowed (classic Rule of Five). Defaults to false
+                 * (all rules must pass).
+                 */
+                allow_single_violation?: boolean;
+            }
+            /**
+             * Filter molecules by RDKit molecular descriptors. Each descriptor is constrained
+             * to a min/max range. Only descriptors you provide are checked — omitted
+             * descriptors are unconstrained.
+             */
+            interface RdkitDescriptorFilterResponse {
+                type: 'rdkit_descriptor_filter';
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                fraction_csp3?: RdkitDescriptorFilterResponse.FractionCsp3;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                mol_logp?: RdkitDescriptorFilterResponse.MolLogp;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                mol_wt?: RdkitDescriptorFilterResponse.MolWt;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_aromatic_rings?: RdkitDescriptorFilterResponse.NumAromaticRings;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_h_acceptors?: RdkitDescriptorFilterResponse.NumHAcceptors;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_h_donors?: RdkitDescriptorFilterResponse.NumHDonors;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_heteroatoms?: RdkitDescriptorFilterResponse.NumHeteroatoms;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_rings?: RdkitDescriptorFilterResponse.NumRings;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_rotatable_bonds?: RdkitDescriptorFilterResponse.NumRotatableBonds;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                tpsa?: RdkitDescriptorFilterResponse.Tpsa;
+            }
+            namespace RdkitDescriptorFilterResponse {
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface FractionCsp3 {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface MolLogp {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface MolWt {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumAromaticRings {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumHAcceptors {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumHDonors {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumHeteroatoms {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumRings {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumRotatableBonds {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface Tpsa {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+            }
+            /**
+             * Filter molecules by custom SMARTS patterns. Molecules matching any pattern are
+             * rejected.
+             */
+            interface SmartsCustomFilterResponse {
+                /**
+                 * SMARTS patterns. Molecules matching any pattern are rejected.
+                 */
+                patterns: Array<string>;
+                type: 'smarts_custom_filter';
+            }
+            /**
+             * Filter molecules using a predefined SMARTS catalog of structural alerts.
+             */
+            interface SmartsCatalogFilterResponse {
+                /**
+                 * Predefined SMARTS catalog to apply. PAINS, BRENK, ChEMBL, and NIH catalogs
+                 * reject known problematic substructures.
+                 */
+                catalog: 'PAINS' | 'PAINS_A' | 'PAINS_B' | 'PAINS_C' | 'BRENK' | 'CHEMBL' | 'CHEMBL_BMS' | 'CHEMBL_Dundee' | 'CHEMBL_Glaxo' | 'CHEMBL_Inpharmatica' | 'CHEMBL_LINT' | 'CHEMBL_MLSMR' | 'CHEMBL_SureChEMBL' | 'NIH';
+                type: 'smarts_catalog_filter';
+            }
+            /**
+             * Filter molecules by regex patterns on their SMILES representation.
+             */
+            interface SmilesRegexFilterResponse {
+                /**
+                 * Regex patterns applied to SMILES strings. Molecules matching any pattern are
+                 * rejected.
+                 */
+                patterns: Array<string>;
+                type: 'smiles_regex_filter';
+            }
+        }
+    }
+    interface Progress {
+        /**
+         * Number of accepted molecules that reached terminal failure during screening.
+         */
+        num_molecules_failed: number;
+        /**
+         * Number of accepted molecules that produced usable screening results.
+         */
+        num_molecules_screened: number;
+        /**
+         * Total number of molecules accepted into screening after server-side validation
+         * and filtering.
+         */
+        total_molecules_to_screen: number;
+        /**
+         * ID of the most recently screened result
+         */
+        latest_result_id?: string;
+        rejection_summary?: Progress.RejectionSummary;
+    }
+    namespace Progress {
+        interface RejectionSummary {
+            /**
+             * Number of submitted molecules removed by server-side filtering rules.
+             */
+            filtered_count: number;
+            /**
+             * Number of submitted molecules rejected as invalid input.
+             */
+            invalid_count: number;
+        }
+    }
+}
+/**
+ * Summary of a small molecule library screening engine run (excludes input)
+ */
+export interface LibraryScreenListResponse {
+    /**
+     * Unique SmScreenSummary identifier
+     */
+    id: string;
+    completed_at: string | null;
+    created_at: string;
+    /**
+     * When the input, output, and result data was permanently deleted. Null if data
+     * has not been deleted.
+     */
+    data_deleted_at: string | null;
+    /**
+     * Engine used for small molecule library screen
+     */
+    engine: 'boltz-sm-screen';
+    /**
+     * Engine version used for small molecule library screen
+     */
+    engine_version: string;
+    error: LibraryScreenListResponse.Error | null;
+    /**
+     * Whether this resource was created with a live API key.
+     */
+    livemode: boolean;
+    progress: LibraryScreenListResponse.Progress | null;
+    started_at: string | null;
+    status: 'pending' | 'running' | 'succeeded' | 'failed' | 'stopped';
+    stopped_at: string | null;
+    /**
+     * Workspace ID
+     */
+    workspace_id: string;
+    /**
+     * Client-provided idempotency key
+     */
+    idempotency_key?: string;
+}
+export declare namespace LibraryScreenListResponse {
+    interface Error {
+        /**
+         * Machine-readable error code
+         */
+        code: string;
+        /**
+         * Human-readable error message
+         */
+        message: string;
+        /**
+         * Additional field-level error details keyed by input path, when available.
+         */
+        details?: unknown;
+    }
+    interface Progress {
+        /**
+         * Number of accepted molecules that reached terminal failure during screening.
+         */
+        num_molecules_failed: number;
+        /**
+         * Number of accepted molecules that produced usable screening results.
+         */
+        num_molecules_screened: number;
+        /**
+         * Total number of molecules accepted into screening after server-side validation
+         * and filtering.
+         */
+        total_molecules_to_screen: number;
+        /**
+         * ID of the most recently screened result
+         */
+        latest_result_id?: string;
+        rejection_summary?: Progress.RejectionSummary;
+    }
+    namespace Progress {
+        interface RejectionSummary {
+            /**
+             * Number of submitted molecules removed by server-side filtering rules.
+             */
+            filtered_count: number;
+            /**
+             * Number of submitted molecules rejected as invalid input.
+             */
+            invalid_count: number;
+        }
+    }
+}
+export interface LibraryScreenDeleteDataResponse {
+    /**
+     * ID of the resource whose data was deleted
+     */
+    id: string;
+    data_deleted: true;
+    /**
+     * When the data was deleted
+     */
+    data_deleted_at: string;
+}
+/**
+ * Estimate response with monetary values encoded as decimal strings to preserve
+ * precision.
+ */
+export interface LibraryScreenEstimateCostResponse {
+    /**
+     * Cost breakdown for the billed application.
+     */
+    breakdown: LibraryScreenEstimateCostResponse.Breakdown;
+    disclaimer: string;
+    /**
+     * Estimated total cost as a decimal string
+     */
+    estimated_cost_usd: string;
+}
+export declare namespace LibraryScreenEstimateCostResponse {
+    /**
+     * Cost breakdown for the billed application.
+     */
+    interface Breakdown {
+        application: 'structure_and_binding' | 'small_molecule_design' | 'small_molecule_library_screen' | 'protein_design' | 'protein_library_screen' | 'adme';
+        /**
+         * Estimated cost per displayed unit as a decimal string, rounded up to 4 decimal
+         * places. This may include token-size multipliers or generation overhead;
+         * estimated_cost_usd is the authoritative total.
+         */
+        cost_per_unit_usd: string;
+        /**
+         * Number of units shown for the estimate. For structure-and-binding, this is the
+         * requested number of samples. For protein and small-molecule design/screen
+         * endpoints, this is the requested number of proteins or molecules.
+         */
+        num_units: number;
+    }
+}
+/**
+ * Result for a single screened small molecule
+ */
+export interface LibraryScreenListResultsResponse {
+    /**
+     * Unique result ID
+     */
+    id: string;
+    artifacts: LibraryScreenListResultsResponse.Artifacts;
+    created_at: string;
+    /**
+     * Scoring metrics for a screened small molecule
+     */
+    metrics: LibraryScreenListResultsResponse.Metrics;
+    /**
+     * SMILES string of the screened molecule
+     */
+    smiles: string;
+    /**
+     * Client-provided identifier for this molecule, if provided
+     */
+    external_id?: string;
+    /**
+     * Warnings about potential quality issues with this result.
+     */
+    warnings?: Array<LibraryScreenListResultsResponse.Warning>;
+}
+export declare namespace LibraryScreenListResultsResponse {
+    interface Artifacts {
+        archive: Artifacts.Archive;
+        structure: Artifacts.Structure;
+    }
+    namespace Artifacts {
+        interface Archive {
+            /**
+             * URL to download the file
+             */
+            url: string;
+            /**
+             * When the presigned URL expires
+             */
+            url_expires_at: string;
+        }
+        interface Structure {
+            /**
+             * URL to download the file
+             */
+            url: string;
+            /**
+             * When the presigned URL expires
+             */
+            url_expires_at: string;
+        }
+    }
+    /**
+     * Scoring metrics for a screened small molecule
+     */
+    interface Metrics {
+        /**
+         * Confidence that the molecule binds the target (0-1). Primary metric for hit
+         * discovery.
+         */
+        binding_confidence: number;
+        /**
+         * Interface pLDDT for the complex (0-1 float). Confidence at the binding
+         * interface.
+         */
+        complex_iplddt: number;
+        /**
+         * pLDDT for the full complex (0-1 float).
+         */
+        complex_plddt: number;
+        /**
+         * Interface predicted TM score (0-1). Confidence in relative positioning of ligand
+         * and protein.
+         */
+        iptm: number;
+        /**
+         * Binding strength ranking score for lead optimization. Higher values indicate
+         * stronger predicted binding.
+         */
+        optimization_score: number;
+        /**
+         * Predicted TM score (0-1). Global structure quality metric.
+         */
+        ptm: number;
+        /**
+         * Confidence in the predicted 3D structure (0-1).
+         */
+        structure_confidence: number;
+    }
+    /**
+     * A warning about a potential quality issue with a result
+     */
+    interface Warning {
+        /**
+         * Machine-readable warning code (e.g. "low_confidence", "unusual_geometry")
+         */
+        code: string;
+        /**
+         * Human-readable description of the warning
+         */
+        message: string;
+    }
+}
+/**
+ * A small molecule library screening engine run
+ */
+export interface LibraryScreenStartResponse {
+    /**
+     * Unique SmScreen identifier
+     */
+    id: string;
+    completed_at: string | null;
+    created_at: string;
+    /**
+     * When the input, output, and result data was permanently deleted. Null if data
+     * has not been deleted.
+     */
+    data_deleted_at: string | null;
+    /**
+     * Engine used for small molecule library screen
+     */
+    engine: 'boltz-sm-screen';
+    /**
+     * Engine version used for small molecule library screen
+     */
+    engine_version: string;
+    error: LibraryScreenStartResponse.Error | null;
+    /**
+     * Pipeline input (null if data deleted)
+     */
+    input: LibraryScreenStartResponse.Input | null;
+    /**
+     * Whether this resource was created with a live API key.
+     */
+    livemode: boolean;
+    progress: LibraryScreenStartResponse.Progress | null;
+    started_at: string | null;
+    status: 'pending' | 'running' | 'succeeded' | 'failed' | 'stopped';
+    stopped_at: string | null;
+    /**
+     * Workspace ID
+     */
+    workspace_id: string;
+    /**
+     * Client-provided idempotency key
+     */
+    idempotency_key?: string;
+}
+export declare namespace LibraryScreenStartResponse {
+    interface Error {
+        /**
+         * Machine-readable error code
+         */
+        code: string;
+        /**
+         * Human-readable error message
+         */
+        message: string;
+        /**
+         * Additional field-level error details keyed by input path, when available.
+         */
+        details?: unknown;
+    }
+    /**
+     * Pipeline input (null if data deleted)
+     */
+    interface Input {
+        molecules: Input.Molecules;
+        /**
+         * Target protein with binding pocket for small molecule design or screening
+         */
+        target: Input.Target;
+        /**
+         * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+         * and custom filters.
+         */
+        molecule_filters?: Input.MoleculeFilters;
+    }
+    namespace Input {
+        interface Molecules {
+            /**
+             * URL to download the file
+             */
+            url: string;
+            /**
+             * When the presigned URL expires
+             */
+            url_expires_at: string;
+        }
+        /**
+         * Target protein with binding pocket for small molecule design or screening
+         */
+        interface Target {
+            /**
+             * Protein entities defining the target structure. Each entity represents a protein
+             * chain.
+             */
+            entities: Array<Target.Entity>;
+            /**
+             * Covalent bond constraints between atoms in the target complex. Atom-level ligand
+             * references currently support ligand_ccd only; ligand_smiles is unsupported.
+             */
+            bonds?: Array<Target.Bond>;
+            /**
+             * Structural constraints (pocket and contact). Atom-level ligand references
+             * currently support ligand_ccd only; ligand_smiles is unsupported.
+             */
+            constraints?: Array<Target.PocketConstraintResponse | Target.ContactConstraintResponse>;
+            /**
+             * Binding pocket residues, keyed by chain ID. Each key is a chain ID (e.g. "A")
+             * and the value is an array of 0-indexed residue indices that define the binding
+             * pocket on that chain. When provided, these residues guide pocket extraction and
+             * add a derived pocket constraint during affinity predictions. That derived
+             * constraint remains separate from any explicit pocket constraints in
+             * target.constraints. When omitted, the model auto-detects the pocket.
+             */
+            pocket_residues?: {
+                [key: string]: Array<number>;
+            };
+            /**
+             * Reference ligands as SMILES strings that help the model identify the binding
+             * pocket. When omitted, a set of drug-like default ligands is used for pocket
+             * detection.
+             */
+            reference_ligands?: Array<string>;
+        }
+        namespace Target {
+            interface Entity {
+                /**
+                 * Chain IDs for this entity
+                 */
+                chain_ids: Array<string>;
+                type: 'protein';
+                /**
+                 * Amino acid sequence (one-letter codes)
+                 */
+                value: string;
+                /**
+                 * Whether the sequence is cyclic
+                 */
+                cyclic?: boolean;
+                /**
+                 * Post-translational modifications. Optional; defaults to an empty list when
+                 * omitted.
+                 */
+                modifications?: Array<Entity.CcdModificationResponse | Entity.SmilesModificationResponse>;
+            }
+            namespace Entity {
+                interface CcdModificationResponse {
+                    /**
+                     * 0-based index of the residue to modify
+                     */
+                    residue_index: number;
+                    type: 'ccd';
+                    /**
+                     * CCD code from RCSB PDB (e.g. 'MSE' for selenomethionine, 'SEP' for
+                     * phosphoserine)
+                     */
+                    value: string;
+                }
+                interface SmilesModificationResponse {
+                    /**
+                     * 0-based index of the residue to modify
+                     */
+                    residue_index: number;
+                    type: 'smiles';
+                    /**
+                     * SMILES string for the modification
+                     */
+                    value: string;
+                }
+            }
+            /**
+             * Bond between two atoms. Atom-level ligand references currently support
+             * ligand_ccd entities only; ligand_smiles is unsupported.
+             */
+            interface Bond {
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                atom1: Bond.LigandAtomResponse | Bond.PolymerAtomResponse;
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                atom2: Bond.LigandAtomResponse | Bond.PolymerAtomResponse;
+            }
+            namespace Bond {
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                     * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    type: 'ligand_atom';
+                }
+                interface PolymerAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB)
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_atom';
+                }
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                     * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    type: 'ligand_atom';
+                }
+                interface PolymerAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB)
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_atom';
+                }
+            }
+            /**
+             * Constrains the binder to interact with specific pocket residues on the target.
+             */
+            interface PocketConstraintResponse {
+                /**
+                 * Chain ID of the binder molecule
+                 */
+                binder_chain_id: string;
+                /**
+                 * Binding pocket residues keyed by chain ID. Each key is a chain ID (e.g. "A") and
+                 * the value is an array of 0-indexed residue indices that define the pocket on
+                 * that chain.
+                 */
+                contact_residues: {
+                    [key: string]: Array<number>;
+                };
+                /**
+                 * Maximum allowed distance in Angstroms between binder and pocket residues.
+                 * Typical range: 4-8 A.
+                 */
+                max_distance_angstrom: number;
+                type: 'pocket';
+                /**
+                 * Whether to force the constraint
+                 */
+                force?: boolean;
+            }
+            /**
+             * Contact constraint between two tokens. Atom-level ligand references currently
+             * support ligand_ccd entities only; ligand_smiles is unsupported.
+             */
+            interface ContactConstraintResponse {
+                /**
+                 * Maximum distance in Angstroms
+                 */
+                max_distance_angstrom: number;
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                token1: ContactConstraintResponse.PolymerContactTokenResponse | ContactConstraintResponse.LigandContactTokenResponse;
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                token2: ContactConstraintResponse.PolymerContactTokenResponse | ContactConstraintResponse.LigandContactTokenResponse;
+                type: 'contact';
+                /**
+                 * Whether to force the constraint
+                 */
+                force?: boolean;
+            }
+            namespace ContactConstraintResponse {
+                interface PolymerContactTokenResponse {
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_contact';
+                }
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandContactTokenResponse {
+                    /**
+                     * Atom name. Atom-level references to ligand_smiles entities are currently
+                     * unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    type: 'ligand_contact';
+                }
+                interface PolymerContactTokenResponse {
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_contact';
+                }
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandContactTokenResponse {
+                    /**
+                     * Atom name. Atom-level references to ligand_smiles entities are currently
+                     * unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    type: 'ligand_contact';
+                }
+            }
+        }
+        /**
+         * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+         * and custom filters.
+         */
+        interface MoleculeFilters {
+            /**
+             * Controls the stringency of Boltz's built-in SMARTS structural alert filtering,
+             * which removes molecules matching known problematic substructures. 'recommended'
+             * (default): applies a curated set of alerts balancing safety and hit rate.
+             * 'extra': adds additional alerts beyond the recommended set for stricter
+             * filtering. 'aggressive': applies the most comprehensive alert set — may reject
+             * viable molecules. 'disabled': turns off Boltz SMARTS filtering entirely; only
+             * custom_filters will be applied.
+             */
+            boltz_smarts_catalog_filter_level?: 'recommended' | 'extra' | 'aggressive' | 'disabled';
+            /**
+             * Custom filters to apply. Molecules must pass all filters (AND logic).
+             */
+            custom_filters?: Array<MoleculeFilters.LipinskiFilterResponse | MoleculeFilters.RdkitDescriptorFilterResponse | MoleculeFilters.SmartsCustomFilterResponse | MoleculeFilters.SmartsCatalogFilterResponse | MoleculeFilters.SmilesRegexFilterResponse>;
+        }
+        namespace MoleculeFilters {
+            /**
+             * Lipinski's Rule of Five filter. Rejects molecules that violate drug-likeness
+             * criteria based on molecular weight, LogP, hydrogen bond donors, and hydrogen
+             * bond acceptors.
+             */
+            interface LipinskiFilterResponse {
+                /**
+                 * Maximum number of hydrogen bond acceptors. Lipinski threshold: 10
+                 */
+                max_hba: number;
+                /**
+                 * Maximum number of hydrogen bond donors. Lipinski threshold: 5
+                 */
+                max_hbd: number;
+                /**
+                 * Maximum LogP. Lipinski threshold: 5
+                 */
+                max_logp: number;
+                /**
+                 * Maximum molecular weight (Da). Lipinski threshold: 500
+                 */
+                max_mw: number;
+                type: 'lipinski_filter';
+                /**
+                 * If true, one rule violation is allowed (classic Rule of Five). Defaults to false
+                 * (all rules must pass).
+                 */
+                allow_single_violation?: boolean;
+            }
+            /**
+             * Filter molecules by RDKit molecular descriptors. Each descriptor is constrained
+             * to a min/max range. Only descriptors you provide are checked — omitted
+             * descriptors are unconstrained.
+             */
+            interface RdkitDescriptorFilterResponse {
+                type: 'rdkit_descriptor_filter';
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                fraction_csp3?: RdkitDescriptorFilterResponse.FractionCsp3;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                mol_logp?: RdkitDescriptorFilterResponse.MolLogp;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                mol_wt?: RdkitDescriptorFilterResponse.MolWt;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_aromatic_rings?: RdkitDescriptorFilterResponse.NumAromaticRings;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_h_acceptors?: RdkitDescriptorFilterResponse.NumHAcceptors;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_h_donors?: RdkitDescriptorFilterResponse.NumHDonors;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_heteroatoms?: RdkitDescriptorFilterResponse.NumHeteroatoms;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_rings?: RdkitDescriptorFilterResponse.NumRings;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_rotatable_bonds?: RdkitDescriptorFilterResponse.NumRotatableBonds;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                tpsa?: RdkitDescriptorFilterResponse.Tpsa;
+            }
+            namespace RdkitDescriptorFilterResponse {
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface FractionCsp3 {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface MolLogp {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface MolWt {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumAromaticRings {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumHAcceptors {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumHDonors {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumHeteroatoms {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumRings {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumRotatableBonds {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface Tpsa {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+            }
+            /**
+             * Filter molecules by custom SMARTS patterns. Molecules matching any pattern are
+             * rejected.
+             */
+            interface SmartsCustomFilterResponse {
+                /**
+                 * SMARTS patterns. Molecules matching any pattern are rejected.
+                 */
+                patterns: Array<string>;
+                type: 'smarts_custom_filter';
+            }
+            /**
+             * Filter molecules using a predefined SMARTS catalog of structural alerts.
+             */
+            interface SmartsCatalogFilterResponse {
+                /**
+                 * Predefined SMARTS catalog to apply. PAINS, BRENK, ChEMBL, and NIH catalogs
+                 * reject known problematic substructures.
+                 */
+                catalog: 'PAINS' | 'PAINS_A' | 'PAINS_B' | 'PAINS_C' | 'BRENK' | 'CHEMBL' | 'CHEMBL_BMS' | 'CHEMBL_Dundee' | 'CHEMBL_Glaxo' | 'CHEMBL_Inpharmatica' | 'CHEMBL_LINT' | 'CHEMBL_MLSMR' | 'CHEMBL_SureChEMBL' | 'NIH';
+                type: 'smarts_catalog_filter';
+            }
+            /**
+             * Filter molecules by regex patterns on their SMILES representation.
+             */
+            interface SmilesRegexFilterResponse {
+                /**
+                 * Regex patterns applied to SMILES strings. Molecules matching any pattern are
+                 * rejected.
+                 */
+                patterns: Array<string>;
+                type: 'smiles_regex_filter';
+            }
+        }
+    }
+    interface Progress {
+        /**
+         * Number of accepted molecules that reached terminal failure during screening.
+         */
+        num_molecules_failed: number;
+        /**
+         * Number of accepted molecules that produced usable screening results.
+         */
+        num_molecules_screened: number;
+        /**
+         * Total number of molecules accepted into screening after server-side validation
+         * and filtering.
+         */
+        total_molecules_to_screen: number;
+        /**
+         * ID of the most recently screened result
+         */
+        latest_result_id?: string;
+        rejection_summary?: Progress.RejectionSummary;
+    }
+    namespace Progress {
+        interface RejectionSummary {
+            /**
+             * Number of submitted molecules removed by server-side filtering rules.
+             */
+            filtered_count: number;
+            /**
+             * Number of submitted molecules rejected as invalid input.
+             */
+            invalid_count: number;
+        }
+    }
+}
+/**
+ * A small molecule library screening engine run
+ */
+export interface LibraryScreenStopResponse {
+    /**
+     * Unique SmScreen identifier
+     */
+    id: string;
+    completed_at: string | null;
+    created_at: string;
+    /**
+     * When the input, output, and result data was permanently deleted. Null if data
+     * has not been deleted.
+     */
+    data_deleted_at: string | null;
+    /**
+     * Engine used for small molecule library screen
+     */
+    engine: 'boltz-sm-screen';
+    /**
+     * Engine version used for small molecule library screen
+     */
+    engine_version: string;
+    error: LibraryScreenStopResponse.Error | null;
+    /**
+     * Pipeline input (null if data deleted)
+     */
+    input: LibraryScreenStopResponse.Input | null;
+    /**
+     * Whether this resource was created with a live API key.
+     */
+    livemode: boolean;
+    progress: LibraryScreenStopResponse.Progress | null;
+    started_at: string | null;
+    status: 'pending' | 'running' | 'succeeded' | 'failed' | 'stopped';
+    stopped_at: string | null;
+    /**
+     * Workspace ID
+     */
+    workspace_id: string;
+    /**
+     * Client-provided idempotency key
+     */
+    idempotency_key?: string;
+}
+export declare namespace LibraryScreenStopResponse {
+    interface Error {
+        /**
+         * Machine-readable error code
+         */
+        code: string;
+        /**
+         * Human-readable error message
+         */
+        message: string;
+        /**
+         * Additional field-level error details keyed by input path, when available.
+         */
+        details?: unknown;
+    }
+    /**
+     * Pipeline input (null if data deleted)
+     */
+    interface Input {
+        molecules: Input.Molecules;
+        /**
+         * Target protein with binding pocket for small molecule design or screening
+         */
+        target: Input.Target;
+        /**
+         * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+         * and custom filters.
+         */
+        molecule_filters?: Input.MoleculeFilters;
+    }
+    namespace Input {
+        interface Molecules {
+            /**
+             * URL to download the file
+             */
+            url: string;
+            /**
+             * When the presigned URL expires
+             */
+            url_expires_at: string;
+        }
+        /**
+         * Target protein with binding pocket for small molecule design or screening
+         */
+        interface Target {
+            /**
+             * Protein entities defining the target structure. Each entity represents a protein
+             * chain.
+             */
+            entities: Array<Target.Entity>;
+            /**
+             * Covalent bond constraints between atoms in the target complex. Atom-level ligand
+             * references currently support ligand_ccd only; ligand_smiles is unsupported.
+             */
+            bonds?: Array<Target.Bond>;
+            /**
+             * Structural constraints (pocket and contact). Atom-level ligand references
+             * currently support ligand_ccd only; ligand_smiles is unsupported.
+             */
+            constraints?: Array<Target.PocketConstraintResponse | Target.ContactConstraintResponse>;
+            /**
+             * Binding pocket residues, keyed by chain ID. Each key is a chain ID (e.g. "A")
+             * and the value is an array of 0-indexed residue indices that define the binding
+             * pocket on that chain. When provided, these residues guide pocket extraction and
+             * add a derived pocket constraint during affinity predictions. That derived
+             * constraint remains separate from any explicit pocket constraints in
+             * target.constraints. When omitted, the model auto-detects the pocket.
+             */
+            pocket_residues?: {
+                [key: string]: Array<number>;
+            };
+            /**
+             * Reference ligands as SMILES strings that help the model identify the binding
+             * pocket. When omitted, a set of drug-like default ligands is used for pocket
+             * detection.
+             */
+            reference_ligands?: Array<string>;
+        }
+        namespace Target {
+            interface Entity {
+                /**
+                 * Chain IDs for this entity
+                 */
+                chain_ids: Array<string>;
+                type: 'protein';
+                /**
+                 * Amino acid sequence (one-letter codes)
+                 */
+                value: string;
+                /**
+                 * Whether the sequence is cyclic
+                 */
+                cyclic?: boolean;
+                /**
+                 * Post-translational modifications. Optional; defaults to an empty list when
+                 * omitted.
+                 */
+                modifications?: Array<Entity.CcdModificationResponse | Entity.SmilesModificationResponse>;
+            }
+            namespace Entity {
+                interface CcdModificationResponse {
+                    /**
+                     * 0-based index of the residue to modify
+                     */
+                    residue_index: number;
+                    type: 'ccd';
+                    /**
+                     * CCD code from RCSB PDB (e.g. 'MSE' for selenomethionine, 'SEP' for
+                     * phosphoserine)
+                     */
+                    value: string;
+                }
+                interface SmilesModificationResponse {
+                    /**
+                     * 0-based index of the residue to modify
+                     */
+                    residue_index: number;
+                    type: 'smiles';
+                    /**
+                     * SMILES string for the modification
+                     */
+                    value: string;
+                }
+            }
+            /**
+             * Bond between two atoms. Atom-level ligand references currently support
+             * ligand_ccd entities only; ligand_smiles is unsupported.
+             */
+            interface Bond {
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                atom1: Bond.LigandAtomResponse | Bond.PolymerAtomResponse;
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                atom2: Bond.LigandAtomResponse | Bond.PolymerAtomResponse;
+            }
+            namespace Bond {
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                     * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    type: 'ligand_atom';
+                }
+                interface PolymerAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB)
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_atom';
+                }
+                /**
+                 * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                     * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    type: 'ligand_atom';
+                }
+                interface PolymerAtomResponse {
+                    /**
+                     * Standardized atom name (verifiable in CIF file on RCSB)
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID containing the atom
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_atom';
+                }
+            }
+            /**
+             * Constrains the binder to interact with specific pocket residues on the target.
+             */
+            interface PocketConstraintResponse {
+                /**
+                 * Chain ID of the binder molecule
+                 */
+                binder_chain_id: string;
+                /**
+                 * Binding pocket residues keyed by chain ID. Each key is a chain ID (e.g. "A") and
+                 * the value is an array of 0-indexed residue indices that define the pocket on
+                 * that chain.
+                 */
+                contact_residues: {
+                    [key: string]: Array<number>;
+                };
+                /**
+                 * Maximum allowed distance in Angstroms between binder and pocket residues.
+                 * Typical range: 4-8 A.
+                 */
+                max_distance_angstrom: number;
+                type: 'pocket';
+                /**
+                 * Whether to force the constraint
+                 */
+                force?: boolean;
+            }
+            /**
+             * Contact constraint between two tokens. Atom-level ligand references currently
+             * support ligand_ccd entities only; ligand_smiles is unsupported.
+             */
+            interface ContactConstraintResponse {
+                /**
+                 * Maximum distance in Angstroms
+                 */
+                max_distance_angstrom: number;
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                token1: ContactConstraintResponse.PolymerContactTokenResponse | ContactConstraintResponse.LigandContactTokenResponse;
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                token2: ContactConstraintResponse.PolymerContactTokenResponse | ContactConstraintResponse.LigandContactTokenResponse;
+                type: 'contact';
+                /**
+                 * Whether to force the constraint
+                 */
+                force?: boolean;
+            }
+            namespace ContactConstraintResponse {
+                interface PolymerContactTokenResponse {
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_contact';
+                }
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandContactTokenResponse {
+                    /**
+                     * Atom name. Atom-level references to ligand_smiles entities are currently
+                     * unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    type: 'ligand_contact';
+                }
+                interface PolymerContactTokenResponse {
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    /**
+                     * 0-based residue index
+                     */
+                    residue_index: number;
+                    type: 'polymer_contact';
+                }
+                /**
+                 * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+                 * entities only; ligand_smiles is unsupported.
+                 */
+                interface LigandContactTokenResponse {
+                    /**
+                     * Atom name. Atom-level references to ligand_smiles entities are currently
+                     * unsupported; use ligand_ccd instead.
+                     */
+                    atom_name: string;
+                    /**
+                     * Chain ID
+                     */
+                    chain_id: string;
+                    type: 'ligand_contact';
+                }
+            }
+        }
+        /**
+         * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+         * and custom filters.
+         */
+        interface MoleculeFilters {
+            /**
+             * Controls the stringency of Boltz's built-in SMARTS structural alert filtering,
+             * which removes molecules matching known problematic substructures. 'recommended'
+             * (default): applies a curated set of alerts balancing safety and hit rate.
+             * 'extra': adds additional alerts beyond the recommended set for stricter
+             * filtering. 'aggressive': applies the most comprehensive alert set — may reject
+             * viable molecules. 'disabled': turns off Boltz SMARTS filtering entirely; only
+             * custom_filters will be applied.
+             */
+            boltz_smarts_catalog_filter_level?: 'recommended' | 'extra' | 'aggressive' | 'disabled';
+            /**
+             * Custom filters to apply. Molecules must pass all filters (AND logic).
+             */
+            custom_filters?: Array<MoleculeFilters.LipinskiFilterResponse | MoleculeFilters.RdkitDescriptorFilterResponse | MoleculeFilters.SmartsCustomFilterResponse | MoleculeFilters.SmartsCatalogFilterResponse | MoleculeFilters.SmilesRegexFilterResponse>;
+        }
+        namespace MoleculeFilters {
+            /**
+             * Lipinski's Rule of Five filter. Rejects molecules that violate drug-likeness
+             * criteria based on molecular weight, LogP, hydrogen bond donors, and hydrogen
+             * bond acceptors.
+             */
+            interface LipinskiFilterResponse {
+                /**
+                 * Maximum number of hydrogen bond acceptors. Lipinski threshold: 10
+                 */
+                max_hba: number;
+                /**
+                 * Maximum number of hydrogen bond donors. Lipinski threshold: 5
+                 */
+                max_hbd: number;
+                /**
+                 * Maximum LogP. Lipinski threshold: 5
+                 */
+                max_logp: number;
+                /**
+                 * Maximum molecular weight (Da). Lipinski threshold: 500
+                 */
+                max_mw: number;
+                type: 'lipinski_filter';
+                /**
+                 * If true, one rule violation is allowed (classic Rule of Five). Defaults to false
+                 * (all rules must pass).
+                 */
+                allow_single_violation?: boolean;
+            }
+            /**
+             * Filter molecules by RDKit molecular descriptors. Each descriptor is constrained
+             * to a min/max range. Only descriptors you provide are checked — omitted
+             * descriptors are unconstrained.
+             */
+            interface RdkitDescriptorFilterResponse {
+                type: 'rdkit_descriptor_filter';
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                fraction_csp3?: RdkitDescriptorFilterResponse.FractionCsp3;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                mol_logp?: RdkitDescriptorFilterResponse.MolLogp;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                mol_wt?: RdkitDescriptorFilterResponse.MolWt;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_aromatic_rings?: RdkitDescriptorFilterResponse.NumAromaticRings;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_h_acceptors?: RdkitDescriptorFilterResponse.NumHAcceptors;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_h_donors?: RdkitDescriptorFilterResponse.NumHDonors;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_heteroatoms?: RdkitDescriptorFilterResponse.NumHeteroatoms;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_rings?: RdkitDescriptorFilterResponse.NumRings;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                num_rotatable_bonds?: RdkitDescriptorFilterResponse.NumRotatableBonds;
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                tpsa?: RdkitDescriptorFilterResponse.Tpsa;
+            }
+            namespace RdkitDescriptorFilterResponse {
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface FractionCsp3 {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface MolLogp {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface MolWt {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumAromaticRings {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumHAcceptors {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumHDonors {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumHeteroatoms {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumRings {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface NumRotatableBonds {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+                /**
+                 * Min/max range constraint for an RDKit molecular descriptor
+                 */
+                interface Tpsa {
+                    /**
+                     * Maximum allowed value (inclusive)
+                     */
+                    max?: number;
+                    /**
+                     * Minimum allowed value (inclusive)
+                     */
+                    min?: number;
+                }
+            }
+            /**
+             * Filter molecules by custom SMARTS patterns. Molecules matching any pattern are
+             * rejected.
+             */
+            interface SmartsCustomFilterResponse {
+                /**
+                 * SMARTS patterns. Molecules matching any pattern are rejected.
+                 */
+                patterns: Array<string>;
+                type: 'smarts_custom_filter';
+            }
+            /**
+             * Filter molecules using a predefined SMARTS catalog of structural alerts.
+             */
+            interface SmartsCatalogFilterResponse {
+                /**
+                 * Predefined SMARTS catalog to apply. PAINS, BRENK, ChEMBL, and NIH catalogs
+                 * reject known problematic substructures.
+                 */
+                catalog: 'PAINS' | 'PAINS_A' | 'PAINS_B' | 'PAINS_C' | 'BRENK' | 'CHEMBL' | 'CHEMBL_BMS' | 'CHEMBL_Dundee' | 'CHEMBL_Glaxo' | 'CHEMBL_Inpharmatica' | 'CHEMBL_LINT' | 'CHEMBL_MLSMR' | 'CHEMBL_SureChEMBL' | 'NIH';
+                type: 'smarts_catalog_filter';
+            }
+            /**
+             * Filter molecules by regex patterns on their SMILES representation.
+             */
+            interface SmilesRegexFilterResponse {
+                /**
+                 * Regex patterns applied to SMILES strings. Molecules matching any pattern are
+                 * rejected.
+                 */
+                patterns: Array<string>;
+                type: 'smiles_regex_filter';
+            }
+        }
+    }
+    interface Progress {
+        /**
+         * Number of accepted molecules that reached terminal failure during screening.
+         */
+        num_molecules_failed: number;
+        /**
+         * Number of accepted molecules that produced usable screening results.
+         */
+        num_molecules_screened: number;
+        /**
+         * Total number of molecules accepted into screening after server-side validation
+         * and filtering.
+         */
+        total_molecules_to_screen: number;
+        /**
+         * ID of the most recently screened result
+         */
+        latest_result_id?: string;
+        rejection_summary?: Progress.RejectionSummary;
+    }
+    namespace Progress {
+        interface RejectionSummary {
+            /**
+             * Number of submitted molecules removed by server-side filtering rules.
+             */
+            filtered_count: number;
+            /**
+             * Number of submitted molecules rejected as invalid input.
+             */
+            invalid_count: number;
+        }
+    }
+}
+export interface LibraryScreenRetrieveParams {
+    /**
+     * Workspace ID. Only used with admin API keys. Ignored (or validated) for
+     * workspace-scoped keys.
+     */
+    workspace_id?: string;
+}
+export interface LibraryScreenListParams extends CursorPageParams {
+    /**
+     * Filter by workspace ID. Only used with admin API keys. If not provided, defaults
+     * to the workspace associated with the API key, or the default workspace for admin
+     * keys.
+     */
+    workspace_id?: string;
+}
+export interface LibraryScreenEstimateCostParams {
+    /**
+     * List of small molecules to screen.
+     */
+    molecules: Array<LibraryScreenEstimateCostParams.Molecule>;
+    /**
+     * Target protein with binding pocket for small molecule design or screening
+     */
+    target: LibraryScreenEstimateCostParams.Target;
+    /**
+     * Client-provided key to prevent duplicate submissions on retries
+     */
+    idempotency_key?: string;
+    /**
+     * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+     * and custom filters.
+     */
+    molecule_filters?: LibraryScreenEstimateCostParams.MoleculeFilters;
+    /**
+     * Target workspace ID (admin keys only; ignored for workspace keys)
+     */
+    workspace_id?: string;
+}
+export declare namespace LibraryScreenEstimateCostParams {
+    /**
+     * A small molecule with SMILES and optional ID
+     */
+    interface Molecule {
+        /**
+         * SMILES string of the molecule
+         */
+        smiles: string;
+        /**
+         * Optional identifier for this molecule
+         */
+        id?: string;
+    }
+    /**
+     * Target protein with binding pocket for small molecule design or screening
+     */
+    interface Target {
+        /**
+         * Protein entities defining the target structure. Each entity represents a protein
+         * chain.
+         */
+        entities: Array<Target.Entity>;
+        /**
+         * Covalent bond constraints between atoms in the target complex. Atom-level ligand
+         * references currently support ligand_ccd only; ligand_smiles is unsupported.
+         */
+        bonds?: Array<Target.Bond>;
+        /**
+         * Structural constraints (pocket and contact). Atom-level ligand references
+         * currently support ligand_ccd only; ligand_smiles is unsupported.
+         */
+        constraints?: Array<Target.PocketConstraint | Target.ContactConstraint>;
+        /**
+         * Binding pocket residues, keyed by chain ID. Each key is a chain ID (e.g. "A")
+         * and the value is an array of 0-indexed residue indices that define the binding
+         * pocket on that chain. When provided, these residues guide pocket extraction and
+         * add a derived pocket constraint during affinity predictions. That derived
+         * constraint remains separate from any explicit pocket constraints in
+         * target.constraints. When omitted, the model auto-detects the pocket.
+         */
+        pocket_residues?: {
+            [key: string]: Array<number>;
+        };
+        /**
+         * Reference ligands as SMILES strings that help the model identify the binding
+         * pocket. When omitted, a set of drug-like default ligands is used for pocket
+         * detection.
+         */
+        reference_ligands?: Array<string>;
+    }
+    namespace Target {
+        interface Entity {
+            /**
+             * Chain IDs for this entity
+             */
+            chain_ids: Array<string>;
+            type: 'protein';
+            /**
+             * Amino acid sequence (one-letter codes)
+             */
+            value: string;
+            /**
+             * Whether the sequence is cyclic
+             */
+            cyclic?: boolean;
+            /**
+             * Post-translational modifications. Optional; defaults to an empty list when
+             * omitted.
+             */
+            modifications?: Array<Entity.CcdModification | Entity.SmilesModification>;
+        }
+        namespace Entity {
+            interface CcdModification {
+                /**
+                 * 0-based index of the residue to modify
+                 */
+                residue_index: number;
+                type: 'ccd';
+                /**
+                 * CCD code from RCSB PDB (e.g. 'MSE' for selenomethionine, 'SEP' for
+                 * phosphoserine)
+                 */
+                value: string;
+            }
+            interface SmilesModification {
+                /**
+                 * 0-based index of the residue to modify
+                 */
+                residue_index: number;
+                type: 'smiles';
+                /**
+                 * SMILES string for the modification
+                 */
+                value: string;
+            }
+        }
+        /**
+         * Bond between two atoms. Atom-level ligand references currently support
+         * ligand_ccd entities only; ligand_smiles is unsupported.
+         */
+        interface Bond {
+            /**
+             * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            atom1: Bond.LigandAtom | Bond.PolymerAtom;
+            /**
+             * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            atom2: Bond.LigandAtom | Bond.PolymerAtom;
+        }
+        namespace Bond {
+            /**
+             * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            interface LigandAtom {
+                /**
+                 * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                 * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID containing the atom
+                 */
+                chain_id: string;
+                type: 'ligand_atom';
+            }
+            interface PolymerAtom {
+                /**
+                 * Standardized atom name (verifiable in CIF file on RCSB)
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID containing the atom
+                 */
+                chain_id: string;
+                /**
+                 * 0-based residue index
+                 */
+                residue_index: number;
+                type: 'polymer_atom';
+            }
+            /**
+             * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            interface LigandAtom {
+                /**
+                 * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                 * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID containing the atom
+                 */
+                chain_id: string;
+                type: 'ligand_atom';
+            }
+            interface PolymerAtom {
+                /**
+                 * Standardized atom name (verifiable in CIF file on RCSB)
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID containing the atom
+                 */
+                chain_id: string;
+                /**
+                 * 0-based residue index
+                 */
+                residue_index: number;
+                type: 'polymer_atom';
+            }
+        }
+        /**
+         * Constrains the binder to interact with specific pocket residues on the target.
+         */
+        interface PocketConstraint {
+            /**
+             * Chain ID of the binder molecule
+             */
+            binder_chain_id: string;
+            /**
+             * Binding pocket residues keyed by chain ID. Each key is a chain ID (e.g. "A") and
+             * the value is an array of 0-indexed residue indices that define the pocket on
+             * that chain.
+             */
+            contact_residues: {
+                [key: string]: Array<number>;
+            };
+            /**
+             * Maximum allowed distance in Angstroms between binder and pocket residues.
+             * Typical range: 4-8 A.
+             */
+            max_distance_angstrom: number;
+            type: 'pocket';
+            /**
+             * Whether to force the constraint
+             */
+            force?: boolean;
+        }
+        /**
+         * Contact constraint between two tokens. Atom-level ligand references currently
+         * support ligand_ccd entities only; ligand_smiles is unsupported.
+         */
+        interface ContactConstraint {
+            /**
+             * Maximum distance in Angstroms
+             */
+            max_distance_angstrom: number;
+            /**
+             * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            token1: ContactConstraint.PolymerContactToken | ContactConstraint.LigandContactToken;
+            /**
+             * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            token2: ContactConstraint.PolymerContactToken | ContactConstraint.LigandContactToken;
+            type: 'contact';
+            /**
+             * Whether to force the constraint
+             */
+            force?: boolean;
+        }
+        namespace ContactConstraint {
+            interface PolymerContactToken {
+                /**
+                 * Chain ID
+                 */
+                chain_id: string;
+                /**
+                 * 0-based residue index
+                 */
+                residue_index: number;
+                type: 'polymer_contact';
+            }
+            /**
+             * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            interface LigandContactToken {
+                /**
+                 * Atom name. Atom-level references to ligand_smiles entities are currently
+                 * unsupported; use ligand_ccd instead.
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID
+                 */
+                chain_id: string;
+                type: 'ligand_contact';
+            }
+            interface PolymerContactToken {
+                /**
+                 * Chain ID
+                 */
+                chain_id: string;
+                /**
+                 * 0-based residue index
+                 */
+                residue_index: number;
+                type: 'polymer_contact';
+            }
+            /**
+             * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            interface LigandContactToken {
+                /**
+                 * Atom name. Atom-level references to ligand_smiles entities are currently
+                 * unsupported; use ligand_ccd instead.
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID
+                 */
+                chain_id: string;
+                type: 'ligand_contact';
+            }
+        }
+    }
+    /**
+     * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+     * and custom filters.
+     */
+    interface MoleculeFilters {
+        /**
+         * Controls the stringency of Boltz's built-in SMARTS structural alert filtering,
+         * which removes molecules matching known problematic substructures. 'recommended'
+         * (default): applies a curated set of alerts balancing safety and hit rate.
+         * 'extra': adds additional alerts beyond the recommended set for stricter
+         * filtering. 'aggressive': applies the most comprehensive alert set — may reject
+         * viable molecules. 'disabled': turns off Boltz SMARTS filtering entirely; only
+         * custom_filters will be applied.
+         */
+        boltz_smarts_catalog_filter_level?: 'recommended' | 'extra' | 'aggressive' | 'disabled';
+        /**
+         * Custom filters to apply. Molecules must pass all filters (AND logic).
+         */
+        custom_filters?: Array<MoleculeFilters.LipinskiFilter | MoleculeFilters.RdkitDescriptorFilter | MoleculeFilters.SmartsCustomFilter | MoleculeFilters.SmartsCatalogFilter | MoleculeFilters.SmilesRegexFilter>;
+    }
+    namespace MoleculeFilters {
+        /**
+         * Lipinski's Rule of Five filter. Rejects molecules that violate drug-likeness
+         * criteria based on molecular weight, LogP, hydrogen bond donors, and hydrogen
+         * bond acceptors.
+         */
+        interface LipinskiFilter {
+            /**
+             * Maximum number of hydrogen bond acceptors. Lipinski threshold: 10
+             */
+            max_hba: number;
+            /**
+             * Maximum number of hydrogen bond donors. Lipinski threshold: 5
+             */
+            max_hbd: number;
+            /**
+             * Maximum LogP. Lipinski threshold: 5
+             */
+            max_logp: number;
+            /**
+             * Maximum molecular weight (Da). Lipinski threshold: 500
+             */
+            max_mw: number;
+            type: 'lipinski_filter';
+            /**
+             * If true, one rule violation is allowed (classic Rule of Five). Defaults to false
+             * (all rules must pass).
+             */
+            allow_single_violation?: boolean;
+        }
+        /**
+         * Filter molecules by RDKit molecular descriptors. Each descriptor is constrained
+         * to a min/max range. Only descriptors you provide are checked — omitted
+         * descriptors are unconstrained.
+         */
+        interface RdkitDescriptorFilter {
+            type: 'rdkit_descriptor_filter';
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            fraction_csp3?: RdkitDescriptorFilter.FractionCsp3;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            mol_logp?: RdkitDescriptorFilter.MolLogp;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            mol_wt?: RdkitDescriptorFilter.MolWt;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_aromatic_rings?: RdkitDescriptorFilter.NumAromaticRings;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_h_acceptors?: RdkitDescriptorFilter.NumHAcceptors;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_h_donors?: RdkitDescriptorFilter.NumHDonors;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_heteroatoms?: RdkitDescriptorFilter.NumHeteroatoms;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_rings?: RdkitDescriptorFilter.NumRings;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_rotatable_bonds?: RdkitDescriptorFilter.NumRotatableBonds;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            tpsa?: RdkitDescriptorFilter.Tpsa;
+        }
+        namespace RdkitDescriptorFilter {
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface FractionCsp3 {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface MolLogp {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface MolWt {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumAromaticRings {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumHAcceptors {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumHDonors {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumHeteroatoms {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumRings {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumRotatableBonds {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface Tpsa {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+        }
+        /**
+         * Filter molecules by custom SMARTS patterns. Molecules matching any pattern are
+         * rejected.
+         */
+        interface SmartsCustomFilter {
+            /**
+             * SMARTS patterns. Molecules matching any pattern are rejected.
+             */
+            patterns: Array<string>;
+            type: 'smarts_custom_filter';
+        }
+        /**
+         * Filter molecules using a predefined SMARTS catalog of structural alerts.
+         */
+        interface SmartsCatalogFilter {
+            /**
+             * Predefined SMARTS catalog to apply. PAINS, BRENK, ChEMBL, and NIH catalogs
+             * reject known problematic substructures.
+             */
+            catalog: 'PAINS' | 'PAINS_A' | 'PAINS_B' | 'PAINS_C' | 'BRENK' | 'CHEMBL' | 'CHEMBL_BMS' | 'CHEMBL_Dundee' | 'CHEMBL_Glaxo' | 'CHEMBL_Inpharmatica' | 'CHEMBL_LINT' | 'CHEMBL_MLSMR' | 'CHEMBL_SureChEMBL' | 'NIH';
+            type: 'smarts_catalog_filter';
+        }
+        /**
+         * Filter molecules by regex patterns on their SMILES representation.
+         */
+        interface SmilesRegexFilter {
+            /**
+             * Regex patterns applied to SMILES strings. Molecules matching any pattern are
+             * rejected.
+             */
+            patterns: Array<string>;
+            type: 'smiles_regex_filter';
+        }
+    }
+}
+export interface LibraryScreenListResultsParams extends CursorPageParams {
+    /**
+     * Workspace ID. Only used with admin API keys. Ignored (or validated) for
+     * workspace-scoped keys.
+     */
+    workspace_id?: string;
+}
+export interface LibraryScreenStartParams {
+    /**
+     * List of small molecules to screen.
+     */
+    molecules: Array<LibraryScreenStartParams.Molecule>;
+    /**
+     * Target protein with binding pocket for small molecule design or screening
+     */
+    target: LibraryScreenStartParams.Target;
+    /**
+     * Client-provided key to prevent duplicate submissions on retries
+     */
+    idempotency_key?: string;
+    /**
+     * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+     * and custom filters.
+     */
+    molecule_filters?: LibraryScreenStartParams.MoleculeFilters;
+    /**
+     * Target workspace ID (admin keys only; ignored for workspace keys)
+     */
+    workspace_id?: string;
+}
+export declare namespace LibraryScreenStartParams {
+    /**
+     * A small molecule with SMILES and optional ID
+     */
+    interface Molecule {
+        /**
+         * SMILES string of the molecule
+         */
+        smiles: string;
+        /**
+         * Optional identifier for this molecule
+         */
+        id?: string;
+    }
+    /**
+     * Target protein with binding pocket for small molecule design or screening
+     */
+    interface Target {
+        /**
+         * Protein entities defining the target structure. Each entity represents a protein
+         * chain.
+         */
+        entities: Array<Target.Entity>;
+        /**
+         * Covalent bond constraints between atoms in the target complex. Atom-level ligand
+         * references currently support ligand_ccd only; ligand_smiles is unsupported.
+         */
+        bonds?: Array<Target.Bond>;
+        /**
+         * Structural constraints (pocket and contact). Atom-level ligand references
+         * currently support ligand_ccd only; ligand_smiles is unsupported.
+         */
+        constraints?: Array<Target.PocketConstraint | Target.ContactConstraint>;
+        /**
+         * Binding pocket residues, keyed by chain ID. Each key is a chain ID (e.g. "A")
+         * and the value is an array of 0-indexed residue indices that define the binding
+         * pocket on that chain. When provided, these residues guide pocket extraction and
+         * add a derived pocket constraint during affinity predictions. That derived
+         * constraint remains separate from any explicit pocket constraints in
+         * target.constraints. When omitted, the model auto-detects the pocket.
+         */
+        pocket_residues?: {
+            [key: string]: Array<number>;
+        };
+        /**
+         * Reference ligands as SMILES strings that help the model identify the binding
+         * pocket. When omitted, a set of drug-like default ligands is used for pocket
+         * detection.
+         */
+        reference_ligands?: Array<string>;
+    }
+    namespace Target {
+        interface Entity {
+            /**
+             * Chain IDs for this entity
+             */
+            chain_ids: Array<string>;
+            type: 'protein';
+            /**
+             * Amino acid sequence (one-letter codes)
+             */
+            value: string;
+            /**
+             * Whether the sequence is cyclic
+             */
+            cyclic?: boolean;
+            /**
+             * Post-translational modifications. Optional; defaults to an empty list when
+             * omitted.
+             */
+            modifications?: Array<Entity.CcdModification | Entity.SmilesModification>;
+        }
+        namespace Entity {
+            interface CcdModification {
+                /**
+                 * 0-based index of the residue to modify
+                 */
+                residue_index: number;
+                type: 'ccd';
+                /**
+                 * CCD code from RCSB PDB (e.g. 'MSE' for selenomethionine, 'SEP' for
+                 * phosphoserine)
+                 */
+                value: string;
+            }
+            interface SmilesModification {
+                /**
+                 * 0-based index of the residue to modify
+                 */
+                residue_index: number;
+                type: 'smiles';
+                /**
+                 * SMILES string for the modification
+                 */
+                value: string;
+            }
+        }
+        /**
+         * Bond between two atoms. Atom-level ligand references currently support
+         * ligand_ccd entities only; ligand_smiles is unsupported.
+         */
+        interface Bond {
+            /**
+             * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            atom1: Bond.LigandAtom | Bond.PolymerAtom;
+            /**
+             * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            atom2: Bond.LigandAtom | Bond.PolymerAtom;
+        }
+        namespace Bond {
+            /**
+             * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            interface LigandAtom {
+                /**
+                 * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                 * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID containing the atom
+                 */
+                chain_id: string;
+                type: 'ligand_atom';
+            }
+            interface PolymerAtom {
+                /**
+                 * Standardized atom name (verifiable in CIF file on RCSB)
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID containing the atom
+                 */
+                chain_id: string;
+                /**
+                 * 0-based residue index
+                 */
+                residue_index: number;
+                type: 'polymer_atom';
+            }
+            /**
+             * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            interface LigandAtom {
+                /**
+                 * Standardized atom name (verifiable in CIF file on RCSB). Atom-level references
+                 * to ligand_smiles entities are currently unsupported; use ligand_ccd instead.
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID containing the atom
+                 */
+                chain_id: string;
+                type: 'ligand_atom';
+            }
+            interface PolymerAtom {
+                /**
+                 * Standardized atom name (verifiable in CIF file on RCSB)
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID containing the atom
+                 */
+                chain_id: string;
+                /**
+                 * 0-based residue index
+                 */
+                residue_index: number;
+                type: 'polymer_atom';
+            }
+        }
+        /**
+         * Constrains the binder to interact with specific pocket residues on the target.
+         */
+        interface PocketConstraint {
+            /**
+             * Chain ID of the binder molecule
+             */
+            binder_chain_id: string;
+            /**
+             * Binding pocket residues keyed by chain ID. Each key is a chain ID (e.g. "A") and
+             * the value is an array of 0-indexed residue indices that define the pocket on
+             * that chain.
+             */
+            contact_residues: {
+                [key: string]: Array<number>;
+            };
+            /**
+             * Maximum allowed distance in Angstroms between binder and pocket residues.
+             * Typical range: 4-8 A.
+             */
+            max_distance_angstrom: number;
+            type: 'pocket';
+            /**
+             * Whether to force the constraint
+             */
+            force?: boolean;
+        }
+        /**
+         * Contact constraint between two tokens. Atom-level ligand references currently
+         * support ligand_ccd entities only; ligand_smiles is unsupported.
+         */
+        interface ContactConstraint {
+            /**
+             * Maximum distance in Angstroms
+             */
+            max_distance_angstrom: number;
+            /**
+             * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            token1: ContactConstraint.PolymerContactToken | ContactConstraint.LigandContactToken;
+            /**
+             * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            token2: ContactConstraint.PolymerContactToken | ContactConstraint.LigandContactToken;
+            type: 'contact';
+            /**
+             * Whether to force the constraint
+             */
+            force?: boolean;
+        }
+        namespace ContactConstraint {
+            interface PolymerContactToken {
+                /**
+                 * Chain ID
+                 */
+                chain_id: string;
+                /**
+                 * 0-based residue index
+                 */
+                residue_index: number;
+                type: 'polymer_contact';
+            }
+            /**
+             * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            interface LigandContactToken {
+                /**
+                 * Atom name. Atom-level references to ligand_smiles entities are currently
+                 * unsupported; use ligand_ccd instead.
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID
+                 */
+                chain_id: string;
+                type: 'ligand_contact';
+            }
+            interface PolymerContactToken {
+                /**
+                 * Chain ID
+                 */
+                chain_id: string;
+                /**
+                 * 0-based residue index
+                 */
+                residue_index: number;
+                type: 'polymer_contact';
+            }
+            /**
+             * Ligand contact token. Atom-level ligand references currently support ligand_ccd
+             * entities only; ligand_smiles is unsupported.
+             */
+            interface LigandContactToken {
+                /**
+                 * Atom name. Atom-level references to ligand_smiles entities are currently
+                 * unsupported; use ligand_ccd instead.
+                 */
+                atom_name: string;
+                /**
+                 * Chain ID
+                 */
+                chain_id: string;
+                type: 'ligand_contact';
+            }
+        }
+    }
+    /**
+     * Molecule filtering configuration. Controls both Boltz built-in SMARTS filtering
+     * and custom filters.
+     */
+    interface MoleculeFilters {
+        /**
+         * Controls the stringency of Boltz's built-in SMARTS structural alert filtering,
+         * which removes molecules matching known problematic substructures. 'recommended'
+         * (default): applies a curated set of alerts balancing safety and hit rate.
+         * 'extra': adds additional alerts beyond the recommended set for stricter
+         * filtering. 'aggressive': applies the most comprehensive alert set — may reject
+         * viable molecules. 'disabled': turns off Boltz SMARTS filtering entirely; only
+         * custom_filters will be applied.
+         */
+        boltz_smarts_catalog_filter_level?: 'recommended' | 'extra' | 'aggressive' | 'disabled';
+        /**
+         * Custom filters to apply. Molecules must pass all filters (AND logic).
+         */
+        custom_filters?: Array<MoleculeFilters.LipinskiFilter | MoleculeFilters.RdkitDescriptorFilter | MoleculeFilters.SmartsCustomFilter | MoleculeFilters.SmartsCatalogFilter | MoleculeFilters.SmilesRegexFilter>;
+    }
+    namespace MoleculeFilters {
+        /**
+         * Lipinski's Rule of Five filter. Rejects molecules that violate drug-likeness
+         * criteria based on molecular weight, LogP, hydrogen bond donors, and hydrogen
+         * bond acceptors.
+         */
+        interface LipinskiFilter {
+            /**
+             * Maximum number of hydrogen bond acceptors. Lipinski threshold: 10
+             */
+            max_hba: number;
+            /**
+             * Maximum number of hydrogen bond donors. Lipinski threshold: 5
+             */
+            max_hbd: number;
+            /**
+             * Maximum LogP. Lipinski threshold: 5
+             */
+            max_logp: number;
+            /**
+             * Maximum molecular weight (Da). Lipinski threshold: 500
+             */
+            max_mw: number;
+            type: 'lipinski_filter';
+            /**
+             * If true, one rule violation is allowed (classic Rule of Five). Defaults to false
+             * (all rules must pass).
+             */
+            allow_single_violation?: boolean;
+        }
+        /**
+         * Filter molecules by RDKit molecular descriptors. Each descriptor is constrained
+         * to a min/max range. Only descriptors you provide are checked — omitted
+         * descriptors are unconstrained.
+         */
+        interface RdkitDescriptorFilter {
+            type: 'rdkit_descriptor_filter';
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            fraction_csp3?: RdkitDescriptorFilter.FractionCsp3;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            mol_logp?: RdkitDescriptorFilter.MolLogp;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            mol_wt?: RdkitDescriptorFilter.MolWt;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_aromatic_rings?: RdkitDescriptorFilter.NumAromaticRings;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_h_acceptors?: RdkitDescriptorFilter.NumHAcceptors;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_h_donors?: RdkitDescriptorFilter.NumHDonors;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_heteroatoms?: RdkitDescriptorFilter.NumHeteroatoms;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_rings?: RdkitDescriptorFilter.NumRings;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            num_rotatable_bonds?: RdkitDescriptorFilter.NumRotatableBonds;
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            tpsa?: RdkitDescriptorFilter.Tpsa;
+        }
+        namespace RdkitDescriptorFilter {
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface FractionCsp3 {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface MolLogp {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface MolWt {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumAromaticRings {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumHAcceptors {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumHDonors {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumHeteroatoms {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumRings {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface NumRotatableBonds {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+            /**
+             * Min/max range constraint for an RDKit molecular descriptor
+             */
+            interface Tpsa {
+                /**
+                 * Maximum allowed value (inclusive)
+                 */
+                max?: number;
+                /**
+                 * Minimum allowed value (inclusive)
+                 */
+                min?: number;
+            }
+        }
+        /**
+         * Filter molecules by custom SMARTS patterns. Molecules matching any pattern are
+         * rejected.
+         */
+        interface SmartsCustomFilter {
+            /**
+             * SMARTS patterns. Molecules matching any pattern are rejected.
+             */
+            patterns: Array<string>;
+            type: 'smarts_custom_filter';
+        }
+        /**
+         * Filter molecules using a predefined SMARTS catalog of structural alerts.
+         */
+        interface SmartsCatalogFilter {
+            /**
+             * Predefined SMARTS catalog to apply. PAINS, BRENK, ChEMBL, and NIH catalogs
+             * reject known problematic substructures.
+             */
+            catalog: 'PAINS' | 'PAINS_A' | 'PAINS_B' | 'PAINS_C' | 'BRENK' | 'CHEMBL' | 'CHEMBL_BMS' | 'CHEMBL_Dundee' | 'CHEMBL_Glaxo' | 'CHEMBL_Inpharmatica' | 'CHEMBL_LINT' | 'CHEMBL_MLSMR' | 'CHEMBL_SureChEMBL' | 'NIH';
+            type: 'smarts_catalog_filter';
+        }
+        /**
+         * Filter molecules by regex patterns on their SMILES representation.
+         */
+        interface SmilesRegexFilter {
+            /**
+             * Regex patterns applied to SMILES strings. Molecules matching any pattern are
+             * rejected.
+             */
+            patterns: Array<string>;
+            type: 'smiles_regex_filter';
+        }
+    }
+}
+export declare namespace LibraryScreen {
+    export { type LibraryScreenRetrieveResponse as LibraryScreenRetrieveResponse, type LibraryScreenListResponse as LibraryScreenListResponse, type LibraryScreenDeleteDataResponse as LibraryScreenDeleteDataResponse, type LibraryScreenEstimateCostResponse as LibraryScreenEstimateCostResponse, type LibraryScreenListResultsResponse as LibraryScreenListResultsResponse, type LibraryScreenStartResponse as LibraryScreenStartResponse, type LibraryScreenStopResponse as LibraryScreenStopResponse, type LibraryScreenListResponsesCursorPage as LibraryScreenListResponsesCursorPage, type LibraryScreenListResultsResponsesCursorPage as LibraryScreenListResultsResponsesCursorPage, type LibraryScreenRetrieveParams as LibraryScreenRetrieveParams, type LibraryScreenListParams as LibraryScreenListParams, type LibraryScreenEstimateCostParams as LibraryScreenEstimateCostParams, type LibraryScreenListResultsParams as LibraryScreenListResultsParams, type LibraryScreenStartParams as LibraryScreenStartParams, };
+}
+//# sourceMappingURL=library-screen.d.ts.map