boltz-api 0.30.3

package/resources/small-molecule/design.d.mts

@@ -0,0 +1,3428 @@
+import { APIResource } from "../../core/resource.mjs";
+import { APIPromise } from "../../core/api-promise.mjs";
+import { CursorPage, type CursorPageParams, PagePromise } from "../../core/pagination.mjs";
+import { RequestOptions } from "../../internal/request-options.mjs";
+/**
+ * Generate novel small molecules optimized for binding to 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 Design extends APIResource {
+    /**
+     * Retrieve a design run by ID, including progress and status
+     *
+     * @example
+     * ```ts
+     * const design = await client.smallMolecule.design.retrieve(
+     *   'id',
+     * );
+     * ```
+     */
+    retrieve(id: string, query?: DesignRetrieveParams | null | undefined, options?: RequestOptions): APIPromise<DesignRetrieveResponse>;
+    /**
+     * List small molecule design runs, optionally filtered by workspace
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const designListResponse of client.smallMolecule.design.list()) {
+     *   // ...
+     * }
+     * ```
+     */
+    list(query?: DesignListParams | null | undefined, options?: RequestOptions): PagePromise<DesignListResponsesCursorPage, DesignListResponse>;
+    /**
+     * Permanently delete the input, output, and result data associated with this
+     * design run. The design run record itself is retained with a `data_deleted_at`
+     * timestamp. This action is irreversible.
+     *
+     * @example
+     * ```ts
+     * const response =
+     *   await client.smallMolecule.design.deleteData('id');
+     * ```
+     */
+    deleteData(id: string, options?: RequestOptions): APIPromise<DesignDeleteDataResponse>;
+    /**
+     * Estimate the billed cost of a small molecule design run without creating any
+     * resource or consuming GPU. Includes the SynFlowNet generation charges implied by
+     * the scheduler iteration cap plus Boltz2 scoring for each requested molecule.
+     *
+     * @example
+     * ```ts
+     * const response =
+     *   await client.smallMolecule.design.estimateCost({
+     *     num_molecules: 10,
+     *     target: {
+     *       entities: [
+     *         {
+     *           chain_ids: ['string'],
+     *           type: 'protein',
+     *           value: 'value',
+     *         },
+     *       ],
+     *     },
+     *   });
+     * ```
+     */
+    estimateCost(body: DesignEstimateCostParams, options?: RequestOptions): APIPromise<DesignEstimateCostResponse>;
+    /**
+     * Retrieve paginated results from a design run
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const designListResultsResponse of client.smallMolecule.design.listResults(
+     *   'id',
+     * )) {
+     *   // ...
+     * }
+     * ```
+     */
+    listResults(id: string, query?: DesignListResultsParams | null | undefined, options?: RequestOptions): PagePromise<DesignListResultsResponsesCursorPage, DesignListResultsResponse>;
+    /**
+     * Create a new design run that generates novel small molecule candidates for a
+     * protein target
+     *
+     * @example
+     * ```ts
+     * const response = await client.smallMolecule.design.start({
+     *   num_molecules: 10,
+     *   target: {
+     *     entities: [
+     *       {
+     *         chain_ids: ['string'],
+     *         type: 'protein',
+     *         value: 'value',
+     *       },
+     *     ],
+     *   },
+     * });
+     * ```
+     */
+    start(body: DesignStartParams, options?: RequestOptions): APIPromise<DesignStartResponse>;
+    /**
+     * Stop an in-progress design run early
+     *
+     * @example
+     * ```ts
+     * const response = await client.smallMolecule.design.stop(
+     *   'id',
+     * );
+     * ```
+     */
+    stop(id: string, options?: RequestOptions): APIPromise<DesignStopResponse>;
+}
+export type DesignListResponsesCursorPage = CursorPage<DesignListResponse>;
+export type DesignListResultsResponsesCursorPage = CursorPage<DesignListResultsResponse>;
+/**
+ * A small molecule design engine run that generates novel molecules
+ */
+export interface DesignRetrieveResponse {
+    /**
+     * Unique SmDesignRun 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 design
+     */
+    engine: 'boltz-sm-design';
+    /**
+     * Engine version used for small molecule design
+     */
+    engine_version: string;
+    error: DesignRetrieveResponse.Error | null;
+    /**
+     * Pipeline input (null if data deleted)
+     */
+    input: DesignRetrieveResponse.Input | null;
+    /**
+     * Whether this resource was created with a live API key.
+     */
+    livemode: boolean;
+    progress: DesignRetrieveResponse.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 DesignRetrieveResponse {
+    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 {
+        /**
+         * Number of molecules to generate. Must be between 10 and 1,000,000.
+         */
+        num_molecules: number;
+        /**
+         * Target protein with binding pocket for small molecule design or screening
+         */
+        target: Input.Target;
+        /**
+         * Chemical space to constrain generated molecules. Currently only 'enamine_real'
+         * (Enamine REAL chemical space) is supported. Additional options may be added in
+         * the future.
+         */
+        chemical_space?: 'enamine_real';
+        /**
+         * 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?: Input.MoleculeFilters;
+        /**
+         * Target workspace ID (admin keys only; ignored for workspace keys)
+         */
+        workspace_id?: string;
+    }
+    namespace Input {
+        /**
+         * 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 molecules generated so far
+         */
+        num_molecules_generated: number;
+        /**
+         * Total number of molecules requested
+         */
+        total_molecules_to_generate: number;
+        /**
+         * ID of the most recently generated result
+         */
+        latest_result_id?: string;
+    }
+}
+/**
+ * Summary of a small molecule design engine run (excludes input)
+ */
+export interface DesignListResponse {
+    /**
+     * Unique SmDesignRunSummary 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 design
+     */
+    engine: 'boltz-sm-design';
+    /**
+     * Engine version used for small molecule design
+     */
+    engine_version: string;
+    error: DesignListResponse.Error | null;
+    /**
+     * Whether this resource was created with a live API key.
+     */
+    livemode: boolean;
+    progress: DesignListResponse.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 DesignListResponse {
+    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 molecules generated so far
+         */
+        num_molecules_generated: number;
+        /**
+         * Total number of molecules requested
+         */
+        total_molecules_to_generate: number;
+        /**
+         * ID of the most recently generated result
+         */
+        latest_result_id?: string;
+    }
+}
+export interface DesignDeleteDataResponse {
+    /**
+     * 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 DesignEstimateCostResponse {
+    /**
+     * Cost breakdown for the billed application.
+     */
+    breakdown: DesignEstimateCostResponse.Breakdown;
+    disclaimer: string;
+    /**
+     * Estimated total cost as a decimal string
+     */
+    estimated_cost_usd: string;
+}
+export declare namespace DesignEstimateCostResponse {
+    /**
+     * 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;
+    }
+}
+/**
+ * A single designed small molecule result
+ */
+export interface DesignListResultsResponse {
+    /**
+     * Unique result ID
+     */
+    id: string;
+    artifacts: DesignListResultsResponse.Artifacts;
+    created_at: string;
+    /**
+     * Scoring metrics for a designed small molecule
+     */
+    metrics: DesignListResultsResponse.Metrics;
+    /**
+     * SMILES string of the designed molecule
+     */
+    smiles: string;
+    /**
+     * Warnings about potential quality issues with this result.
+     */
+    warnings?: Array<DesignListResultsResponse.Warning>;
+}
+export declare namespace DesignListResultsResponse {
+    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 designed 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 design engine run that generates novel molecules
+ */
+export interface DesignStartResponse {
+    /**
+     * Unique SmDesignRun 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 design
+     */
+    engine: 'boltz-sm-design';
+    /**
+     * Engine version used for small molecule design
+     */
+    engine_version: string;
+    error: DesignStartResponse.Error | null;
+    /**
+     * Pipeline input (null if data deleted)
+     */
+    input: DesignStartResponse.Input | null;
+    /**
+     * Whether this resource was created with a live API key.
+     */
+    livemode: boolean;
+    progress: DesignStartResponse.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 DesignStartResponse {
+    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 {
+        /**
+         * Number of molecules to generate. Must be between 10 and 1,000,000.
+         */
+        num_molecules: number;
+        /**
+         * Target protein with binding pocket for small molecule design or screening
+         */
+        target: Input.Target;
+        /**
+         * Chemical space to constrain generated molecules. Currently only 'enamine_real'
+         * (Enamine REAL chemical space) is supported. Additional options may be added in
+         * the future.
+         */
+        chemical_space?: 'enamine_real';
+        /**
+         * 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?: Input.MoleculeFilters;
+        /**
+         * Target workspace ID (admin keys only; ignored for workspace keys)
+         */
+        workspace_id?: string;
+    }
+    namespace Input {
+        /**
+         * 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 molecules generated so far
+         */
+        num_molecules_generated: number;
+        /**
+         * Total number of molecules requested
+         */
+        total_molecules_to_generate: number;
+        /**
+         * ID of the most recently generated result
+         */
+        latest_result_id?: string;
+    }
+}
+/**
+ * A small molecule design engine run that generates novel molecules
+ */
+export interface DesignStopResponse {
+    /**
+     * Unique SmDesignRun 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 design
+     */
+    engine: 'boltz-sm-design';
+    /**
+     * Engine version used for small molecule design
+     */
+    engine_version: string;
+    error: DesignStopResponse.Error | null;
+    /**
+     * Pipeline input (null if data deleted)
+     */
+    input: DesignStopResponse.Input | null;
+    /**
+     * Whether this resource was created with a live API key.
+     */
+    livemode: boolean;
+    progress: DesignStopResponse.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 DesignStopResponse {
+    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 {
+        /**
+         * Number of molecules to generate. Must be between 10 and 1,000,000.
+         */
+        num_molecules: number;
+        /**
+         * Target protein with binding pocket for small molecule design or screening
+         */
+        target: Input.Target;
+        /**
+         * Chemical space to constrain generated molecules. Currently only 'enamine_real'
+         * (Enamine REAL chemical space) is supported. Additional options may be added in
+         * the future.
+         */
+        chemical_space?: 'enamine_real';
+        /**
+         * 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?: Input.MoleculeFilters;
+        /**
+         * Target workspace ID (admin keys only; ignored for workspace keys)
+         */
+        workspace_id?: string;
+    }
+    namespace Input {
+        /**
+         * 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 molecules generated so far
+         */
+        num_molecules_generated: number;
+        /**
+         * Total number of molecules requested
+         */
+        total_molecules_to_generate: number;
+        /**
+         * ID of the most recently generated result
+         */
+        latest_result_id?: string;
+    }
+}
+export interface DesignRetrieveParams {
+    /**
+     * Workspace ID. Only used with admin API keys. Ignored (or validated) for
+     * workspace-scoped keys.
+     */
+    workspace_id?: string;
+}
+export interface DesignListParams 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 DesignEstimateCostParams {
+    /**
+     * Number of molecules to generate. Must be between 10 and 1,000,000.
+     */
+    num_molecules: number;
+    /**
+     * Target protein with binding pocket for small molecule design or screening
+     */
+    target: DesignEstimateCostParams.Target;
+    /**
+     * Chemical space to constrain generated molecules. Currently only 'enamine_real'
+     * (Enamine REAL chemical space) is supported. Additional options may be added in
+     * the future.
+     */
+    chemical_space?: 'enamine_real';
+    /**
+     * 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?: DesignEstimateCostParams.MoleculeFilters;
+    /**
+     * Target workspace ID (admin keys only; ignored for workspace keys)
+     */
+    workspace_id?: string;
+}
+export declare namespace DesignEstimateCostParams {
+    /**
+     * 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 DesignListResultsParams extends CursorPageParams {
+    /**
+     * Workspace ID. Only used with admin API keys. Ignored (or validated) for
+     * workspace-scoped keys.
+     */
+    workspace_id?: string;
+}
+export interface DesignStartParams {
+    /**
+     * Number of molecules to generate. Must be between 10 and 1,000,000.
+     */
+    num_molecules: number;
+    /**
+     * Target protein with binding pocket for small molecule design or screening
+     */
+    target: DesignStartParams.Target;
+    /**
+     * Chemical space to constrain generated molecules. Currently only 'enamine_real'
+     * (Enamine REAL chemical space) is supported. Additional options may be added in
+     * the future.
+     */
+    chemical_space?: 'enamine_real';
+    /**
+     * 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?: DesignStartParams.MoleculeFilters;
+    /**
+     * Target workspace ID (admin keys only; ignored for workspace keys)
+     */
+    workspace_id?: string;
+}
+export declare namespace DesignStartParams {
+    /**
+     * 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 Design {
+    export { type DesignRetrieveResponse as DesignRetrieveResponse, type DesignListResponse as DesignListResponse, type DesignDeleteDataResponse as DesignDeleteDataResponse, type DesignEstimateCostResponse as DesignEstimateCostResponse, type DesignListResultsResponse as DesignListResultsResponse, type DesignStartResponse as DesignStartResponse, type DesignStopResponse as DesignStopResponse, type DesignListResponsesCursorPage as DesignListResponsesCursorPage, type DesignListResultsResponsesCursorPage as DesignListResultsResponsesCursorPage, type DesignRetrieveParams as DesignRetrieveParams, type DesignListParams as DesignListParams, type DesignEstimateCostParams as DesignEstimateCostParams, type DesignListResultsParams as DesignListResultsParams, type DesignStartParams as DesignStartParams, };
+}
+//# sourceMappingURL=design.d.mts.map