boltz-api 0.30.3

package/src/resources/small-molecule/design.ts

@@ -0,0 +1,4229 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { CursorPage, type CursorPageParams, PagePromise } from '../../core/pagination';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+/**
+ * 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 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> {
+    return this._client.get(path`/compute/v1/small-molecule/design/${id}`, { query, ...options });
+  }
+
+  /**
+   * 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> {
+    return this._client.getAPIList('/compute/v1/small-molecule/design', CursorPage<DesignListResponse>, {
+      query,
+      ...options,
+    });
+  }
+
+  /**
+   * 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> {
+    return this._client.post(path`/compute/v1/small-molecule/design/${id}/delete-data`, options);
+  }
+
+  /**
+   * 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> {
+    return this._client.post('/compute/v1/small-molecule/design/estimate-cost', { body, ...options });
+  }
+
+  /**
+   * 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> {
+    return this._client.getAPIList(
+      path`/compute/v1/small-molecule/design/${id}/results`,
+      CursorPage<DesignListResultsResponse>,
+      { query, ...options },
+    );
+  }
+
+  /**
+   * 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> {
+    return this._client.post('/compute/v1/small-molecule/design', { body, ...options });
+  }
+
+  /**
+   * Stop an in-progress design run early
+   *
+   * @example
+   * ```ts
+   * const response = await client.smallMolecule.design.stop(
+   *   'id',
+   * );
+   * ```
+   */
+  stop(id: string, options?: RequestOptions): APIPromise<DesignStopResponse> {
+    return this._client.post(path`/compute/v1/small-molecule/design/${id}/stop`, options);
+  }
+}
+
+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 namespace DesignRetrieveResponse {
+  export 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)
+   */
+  export 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;
+  }
+
+  export namespace Input {
+    /**
+     * Target protein with binding pocket for small molecule design or screening
+     */
+    export 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>;
+    }
+
+    export namespace Target {
+      export 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>;
+      }
+
+      export namespace Entity {
+        export 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;
+        }
+
+        export 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.
+       */
+      export 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;
+      }
+
+      export namespace Bond {
+        /**
+         * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+         * entities only; ligand_smiles is unsupported.
+         */
+        export 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';
+        }
+
+        export 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.
+         */
+        export 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';
+        }
+
+        export 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.
+       */
+      export 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.
+       */
+      export 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;
+      }
+
+      export namespace ContactConstraintResponse {
+        export 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.
+         */
+        export 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';
+        }
+
+        export 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.
+         */
+        export 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.
+     */
+    export 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
+      >;
+    }
+
+    export 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.
+       */
+      export 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.
+       */
+      export 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;
+      }
+
+      export namespace RdkitDescriptorFilterResponse {
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface FractionCsp3 {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface MolLogp {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface MolWt {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumAromaticRings {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumHAcceptors {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumHDonors {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumHeteroatoms {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumRings {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumRotatableBonds {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export 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.
+       */
+      export 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.
+       */
+      export 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.
+       */
+      export interface SmilesRegexFilterResponse {
+        /**
+         * Regex patterns applied to SMILES strings. Molecules matching any pattern are
+         * rejected.
+         */
+        patterns: Array<string>;
+
+        type: 'smiles_regex_filter';
+      }
+    }
+  }
+
+  export 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 namespace DesignListResponse {
+  export 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;
+  }
+
+  export 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 namespace DesignEstimateCostResponse {
+  /**
+   * Cost breakdown for the billed application.
+   */
+  export 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 namespace DesignListResultsResponse {
+  export interface Artifacts {
+    archive: Artifacts.Archive;
+
+    structure: Artifacts.Structure;
+  }
+
+  export namespace Artifacts {
+    export interface Archive {
+      /**
+       * URL to download the file
+       */
+      url: string;
+
+      /**
+       * When the presigned URL expires
+       */
+      url_expires_at: string;
+    }
+
+    export 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
+   */
+  export 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
+   */
+  export 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 namespace DesignStartResponse {
+  export 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)
+   */
+  export 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;
+  }
+
+  export namespace Input {
+    /**
+     * Target protein with binding pocket for small molecule design or screening
+     */
+    export 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>;
+    }
+
+    export namespace Target {
+      export 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>;
+      }
+
+      export namespace Entity {
+        export 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;
+        }
+
+        export 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.
+       */
+      export 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;
+      }
+
+      export namespace Bond {
+        /**
+         * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+         * entities only; ligand_smiles is unsupported.
+         */
+        export 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';
+        }
+
+        export 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.
+         */
+        export 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';
+        }
+
+        export 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.
+       */
+      export 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.
+       */
+      export 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;
+      }
+
+      export namespace ContactConstraintResponse {
+        export 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.
+         */
+        export 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';
+        }
+
+        export 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.
+         */
+        export 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.
+     */
+    export 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
+      >;
+    }
+
+    export 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.
+       */
+      export 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.
+       */
+      export 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;
+      }
+
+      export namespace RdkitDescriptorFilterResponse {
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface FractionCsp3 {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface MolLogp {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface MolWt {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumAromaticRings {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumHAcceptors {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumHDonors {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumHeteroatoms {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumRings {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumRotatableBonds {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export 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.
+       */
+      export 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.
+       */
+      export 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.
+       */
+      export interface SmilesRegexFilterResponse {
+        /**
+         * Regex patterns applied to SMILES strings. Molecules matching any pattern are
+         * rejected.
+         */
+        patterns: Array<string>;
+
+        type: 'smiles_regex_filter';
+      }
+    }
+  }
+
+  export 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 namespace DesignStopResponse {
+  export 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)
+   */
+  export 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;
+  }
+
+  export namespace Input {
+    /**
+     * Target protein with binding pocket for small molecule design or screening
+     */
+    export 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>;
+    }
+
+    export namespace Target {
+      export 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>;
+      }
+
+      export namespace Entity {
+        export 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;
+        }
+
+        export 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.
+       */
+      export 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;
+      }
+
+      export namespace Bond {
+        /**
+         * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+         * entities only; ligand_smiles is unsupported.
+         */
+        export 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';
+        }
+
+        export 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.
+         */
+        export 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';
+        }
+
+        export 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.
+       */
+      export 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.
+       */
+      export 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;
+      }
+
+      export namespace ContactConstraintResponse {
+        export 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.
+         */
+        export 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';
+        }
+
+        export 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.
+         */
+        export 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.
+     */
+    export 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
+      >;
+    }
+
+    export 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.
+       */
+      export 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.
+       */
+      export 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;
+      }
+
+      export namespace RdkitDescriptorFilterResponse {
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface FractionCsp3 {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface MolLogp {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface MolWt {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumAromaticRings {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumHAcceptors {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumHDonors {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumHeteroatoms {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumRings {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export interface NumRotatableBonds {
+          /**
+           * Maximum allowed value (inclusive)
+           */
+          max?: number;
+
+          /**
+           * Minimum allowed value (inclusive)
+           */
+          min?: number;
+        }
+
+        /**
+         * Min/max range constraint for an RDKit molecular descriptor
+         */
+        export 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.
+       */
+      export 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.
+       */
+      export 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.
+       */
+      export interface SmilesRegexFilterResponse {
+        /**
+         * Regex patterns applied to SMILES strings. Molecules matching any pattern are
+         * rejected.
+         */
+        patterns: Array<string>;
+
+        type: 'smiles_regex_filter';
+      }
+    }
+  }
+
+  export 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 namespace DesignEstimateCostParams {
+  /**
+   * Target protein with binding pocket for small molecule design or screening
+   */
+  export 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>;
+  }
+
+  export namespace Target {
+    export 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>;
+    }
+
+    export namespace Entity {
+      export 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;
+      }
+
+      export 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.
+     */
+    export 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;
+    }
+
+    export namespace Bond {
+      /**
+       * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+       * entities only; ligand_smiles is unsupported.
+       */
+      export 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';
+      }
+
+      export 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.
+       */
+      export 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';
+      }
+
+      export 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.
+     */
+    export 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.
+     */
+    export 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;
+    }
+
+    export namespace ContactConstraint {
+      export 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.
+       */
+      export 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';
+      }
+
+      export 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.
+       */
+      export 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.
+   */
+  export 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
+    >;
+  }
+
+  export 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.
+     */
+    export 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.
+     */
+    export 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;
+    }
+
+    export namespace RdkitDescriptorFilter {
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface FractionCsp3 {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface MolLogp {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface MolWt {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumAromaticRings {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumHAcceptors {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumHDonors {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumHeteroatoms {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumRings {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumRotatableBonds {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export 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.
+     */
+    export 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.
+     */
+    export 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.
+     */
+    export 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 namespace DesignStartParams {
+  /**
+   * Target protein with binding pocket for small molecule design or screening
+   */
+  export 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>;
+  }
+
+  export namespace Target {
+    export 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>;
+    }
+
+    export namespace Entity {
+      export 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;
+      }
+
+      export 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.
+     */
+    export 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;
+    }
+
+    export namespace Bond {
+      /**
+       * Ligand atom reference. Atom-level ligand references currently support ligand_ccd
+       * entities only; ligand_smiles is unsupported.
+       */
+      export 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';
+      }
+
+      export 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.
+       */
+      export 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';
+      }
+
+      export 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.
+     */
+    export 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.
+     */
+    export 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;
+    }
+
+    export namespace ContactConstraint {
+      export 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.
+       */
+      export 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';
+      }
+
+      export 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.
+       */
+      export 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.
+   */
+  export 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
+    >;
+  }
+
+  export 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.
+     */
+    export 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.
+     */
+    export 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;
+    }
+
+    export namespace RdkitDescriptorFilter {
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface FractionCsp3 {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface MolLogp {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface MolWt {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumAromaticRings {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumHAcceptors {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumHDonors {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumHeteroatoms {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumRings {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export interface NumRotatableBonds {
+        /**
+         * Maximum allowed value (inclusive)
+         */
+        max?: number;
+
+        /**
+         * Minimum allowed value (inclusive)
+         */
+        min?: number;
+      }
+
+      /**
+       * Min/max range constraint for an RDKit molecular descriptor
+       */
+      export 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.
+     */
+    export 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.
+     */
+    export 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.
+     */
+    export 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,
+  };
+}