@jax-data-science/api-clients 0.0.1 → 0.1.0-a.0

package/index.d.ts

@@ -1,17 +1,859 @@
-export * from './lib/services/asynctask/asynctask.service';
-export * from './lib/services/asynctask/asynctask.model';
-export * from './lib/services/isa-data/isa-data.service';
-export * from './lib/models/isa-data/isa-data.model';
-export * from './lib/tokens/isa-data-config.token';
-export * from './lib/services/mvar/mvar.service';
-export * from './lib/services/mvar/models/response/dtos';
-export * from './lib/services/mvar/mvar-client.module';
-export * from './lib/services/ontology/ontology.service.base';
-export * from './lib/services/ontology/ontology.service.jax';
-export * from './lib/services/ontology/ontology.service.ols';
-export * from './lib/services/mvar/mvar.service';
-export * from './lib/services/mvar/models/response/dtos';
-export * from './lib/services/mvar/mvar-client.module';
-export * from './lib/services/snp-grid/snp-grid-client.module';
-export * from './lib/services/snp-grid/models/response/dtos';
-export * from './lib/services/snp-grid/snp-grid.service';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, ModuleWithProviders } from '@angular/core';
+import * as i1 from '@angular/common';
+
+/**
+ * AsyncTask Service Models
+ *
+ * This module contains TypeScript interfaces for the AsyncTask service API.
+ * These models are based on the OpenAPI specification and represent the
+ * core entities used in the AsyncTask workflow system.
+ */
+/**
+ * Represents the current execution status of a workflow.
+ * Based on temporalio.api.enums.v1.WorkflowExecutionStatus
+ */
+declare enum WorkflowExecutionStatus {
+    RUNNING = 1,
+    COMPLETED = 2,
+    FAILED = 3,
+    CANCELED = 4,
+    TERMINATED = 5,
+    CONTINUED_AS_NEW = 6,
+    TIMED_OUT = 7
+}
+/**
+ * Represents a configuration of input parameters for a workflow run.
+ */
+interface Input {
+    /**
+     * Auto-generated primary key
+     */
+    id?: number | null;
+    /**
+     * Type of the input
+     */
+    type?: string | null;
+    /**
+     * Foreign key to the user who created this input
+     */
+    owner_id: number;
+    /**
+     * JSON dictionary containing input parameters
+     */
+    values: Record<string, any>;
+    /**
+     * Optional descriptive name
+     */
+    name?: string | null;
+    /**
+     * Optional detailed description
+     */
+    description?: string | null;
+}
+/**
+ * Lightweight reference to an input configuration.
+ * Used for list endpoints to minimize data transfer.
+ */
+interface InputReference {
+    /**
+     * Input identifier
+     */
+    id: number;
+    /**
+     * Optional descriptive name
+     */
+    name?: string | null;
+    /**
+     * Optional detailed description
+     */
+    description?: string | null;
+}
+/**
+ * Input submission for creating a new workflow run
+ */
+interface InputSubmission {
+    /**
+     * Optional descriptive name
+     */
+    name?: string | null;
+    /**
+     * Optional detailed description
+     */
+    description?: string | null;
+    /**
+     * Type of task to execute
+     */
+    task_type: string;
+    /**
+     * Input values specific to the task type
+     */
+    values: Record<string, any> | string;
+}
+/**
+ * Represents output data from a completed workflow run.
+ */
+interface Result {
+    /**
+     * Auto-generated primary key
+     */
+    id: number;
+    /**
+     * Foreign key to the associated run
+     */
+    run_id: number;
+    /**
+     * JSON dictionary containing result data
+     */
+    values: Record<string, any>;
+    /**
+     * Optional descriptive name
+     */
+    name?: string | null;
+    /**
+     * Optional detailed description
+     */
+    description?: string | null;
+}
+/**
+ * Lightweight reference to a result.
+ * Used for list endpoints to minimize data transfer.
+ */
+interface ResultReference {
+    /**
+     * Result identifier
+     */
+    id: number;
+    /**
+     * Associated run identifier
+     */
+    run_id: number;
+    /**
+     * Optional descriptive name
+     */
+    name?: string | null;
+    /**
+     * Optional detailed description
+     */
+    description?: string | null;
+}
+/**
+ * Represents an execution instance of a workflow.
+ */
+interface Run {
+    /**
+     * Auto-generated primary key
+     */
+    id: number;
+    /**
+     * Foreign key to the input configuration
+     */
+    input_id: number;
+    /**
+     * Foreign key to the user who initiated the run
+     */
+    owner_id: number;
+    /**
+     * Temporal workflow identifier
+     */
+    workflow_id: string;
+    /**
+     * Current execution status from Temporal
+     */
+    status: WorkflowExecutionStatus;
+    /**
+     * Run start time in ISO 8601 format
+     */
+    init_time?: string | null;
+}
+
+interface BaseResponse {
+    errors?: Error[];
+    info?: Record<string, any>;
+}
+
+interface PagingLinks {
+    first?: string;
+    previous?: string;
+    next?: string;
+    last?: string;
+}
+interface Paging {
+    page?: number;
+    items?: number;
+    total_pages?: number;
+    total_items?: number;
+    links?: PagingLinks;
+}
+
+interface Response<T> extends BaseResponse {
+    object?: T;
+}
+interface CollectionResponse<T> extends BaseResponse {
+    data: T[];
+    paging?: Paging;
+}
+
+declare class AsyncTaskService {
+    private apiBaseUrl;
+    private apiServiceFactory;
+    private apiBaseService;
+    setApiBaseUrl(baseUrl: string): void;
+    getApiBaseUrl(): string;
+    addInput(inputSubmission: InputSubmission): Observable<Response<Input>>;
+    getInput(id: number): Observable<Response<Input>>;
+    getInputs(): Observable<CollectionResponse<InputReference>>;
+    /**
+     * Updates an existing input - only 'name' and 'description' can be updated
+     * @param inputId
+     * @param name - (optional) name to update
+     * @param description - (optional) description to update
+     */
+    updateInput(inputId: number, name?: string, description?: string): Observable<Response<InputReference>>;
+    createRun(inputId?: number, inputSubmission?: InputSubmission): Observable<Response<Run>>;
+    getRun(id: number): Observable<Response<Run>>;
+    /**
+     *
+     * @param workflowId - (optional) workflow identifier
+     */
+    getRuns(workflowId?: string): Observable<CollectionResponse<Run>>;
+    /**
+     * Gets the input associated with the specific run ID. One run is associated
+     * with only one input, so this function returns a single input object.
+     * @param runId
+     */
+    getRunInput(runId: number): Observable<Response<Input>>;
+    /**
+     * Gets the result associated with the specific run ID. One run is associated
+     * with only one result, so this function returns a single result object.
+     * @param runId
+     */
+    getRunResult(runId: number): Observable<Response<Result>>;
+    /**
+     * Calls the fetchEventSource() function, which is a wrapper around the native
+     * EventSource API. This function is used to establish connection to an API
+     * endpoint and listen to event streaming data associated with task runs.
+     * TO-DO [GIK 7/9/2025]: needs to add a reconnect logic
+     * @return an observable that emits run events
+     */
+    getRunEvents(accessToken: string): Observable<Run>;
+    getResult(resId: number): Observable<Response<Result>>;
+    getResults(): Observable<CollectionResponse<ResultReference>>;
+    /**
+     * Updates an existing result record - 'name' and 'description' can be updated
+     * @param resId
+     * @param name - (optional) result's name to update
+     * @param description - (optional) result's description to update
+     */
+    updateResult(resId: number, name?: string, description?: string): Observable<Response<ResultReference>>;
+    getHealthCheck(): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncTaskService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AsyncTaskService>;
+}
+
+/**
+ * This module defines the data models for representing the Investigation-Study-Assay (ISA)
+ * data model, which is a standard for describing life science experiments and their results.
+ *
+ * Key Concepts:
+ * - Investigation: The overall research project or study.
+ * - Study: A specific experimental design within an investigation.
+ * - Assay: A specific test or measurement performed on samples within a study.
+ *
+ * Measures represent the actual data points collected from assay executions, including:
+ * - Measure: a single assay results with unique identifier
+ * - MeasureSeries: a collection of measures that share common metadata and characteristics
+ *
+ * Each measure/series contains values, metadata about the experimental conditions,
+ * and characteristics that describe sample properties or experimental parameters.
+ */
+interface Measure {
+    id: string;
+    values?: MeasureValue[];
+    metadata?: MeasureMetadata;
+    characteristics?: IsaCharacteristic[];
+}
+interface MeasureSeries {
+    id: string;
+    values?: MeasureValue[];
+    measures?: string[];
+    metadata?: MeasureSeriesMetadata;
+    characteristics?: IsaCharacteristic[];
+}
+interface MeasureMetadata {
+    assay_id: number;
+    description: string;
+    measure_id: number;
+    method: string;
+    study_id: string;
+    units: string;
+    treatment: string;
+    variable_name: string;
+    characteristics?: Record<string, string[]>;
+}
+interface MeasureSeriesMetadata {
+    assay_id: number;
+    description: string;
+    initiated_at_units?: string;
+    measure_ids: string[];
+    measure_series_id: string;
+    measurement_units: string;
+    method: string;
+    study_id?: number;
+    treatment: string;
+    treatment_units: string;
+    variable_name: string;
+    characteristics?: Record<string, string[]>;
+}
+interface MeasureValue {
+    value: string | number;
+    measure_id: string;
+    measure_series_id?: string;
+    study_id?: string;
+    source_id: string;
+}
+interface IsaCharacteristicValue {
+    value: string | number | boolean | Date;
+    label: string;
+    count?: number;
+    description?: string;
+    metadata: Record<string, string>;
+}
+interface IsaCharacteristic {
+    name: string;
+    value: IsaCharacteristicValue | IsaCharacteristicValue[];
+    type?: string;
+    unit?: string;
+    description?: string;
+}
+
+/**
+ * service for interacting with ISA (Investigation-Study-Assay) data model API.
+ */
+declare class ISADataService {
+    private readonly apiConfig;
+    private readonly apiServiceFactory;
+    private readonly apiBaseService;
+    constructor();
+    getApiBaseUrl(): string;
+    /**
+     * Fetches measure series metadata for the given measure series IDs and study IDs.
+     *
+     * @param measureSeriesIds - measure series identifiers to fetch metadata for. ONLY ONE ID IS SUPPORTED.
+     * @param studyIds - ONLY ONE ID IS SUPPORTED. REQUIRED!! WILL BE REMOVED IN THE FUTURE.
+     *
+     * @return Observable<Response<MeasureSeriesMetadata>> - an observable containing the measure series metadata.
+     */
+    getMeasureSeriesMetadata(measureSeriesIds: string[], studyIds: string[]): Observable<Response<MeasureSeriesMetadata>>;
+    /**
+     * THIS METHOD SHOULD NOT BE USED. PLACEHOLDER FOR FUTURE IMPLEMENTATION ONCE THE API GROWS.
+     */
+    getMeasuresMetadata(measureIds: string[], studyIds: string[]): Observable<Response<MeasureMetadata>>;
+    /**
+     * Fetches measure series characteristics for the given measure series IDs and study IDs.
+     *
+     * @param measureSeriesIds - measure series identifiers to fetch metadata for. ONLY ONE ID IS SUPPORTED.
+     * @param studyIds - ONLY ONE ID IS SUPPORTED. REQUIRED!! WILL BE REMOVED IN THE FUTURE.
+     *
+     * @return Observable<Response<MeasureSeriesMetadata>> - an observable containing the measure series metadata.
+     */
+    getMeasureSeriesCharacteristics(measureSeriesIds: string[], studyIds: string[]): Observable<Response<IsaCharacteristic>>;
+    /**
+     * Placeholder for assay operations
+     * TODO: Implement assay-related methods
+     */
+    /**
+     * Placeholder for study operations
+     * TODO: Implement study-related methods
+     */
+    /**
+     * Placeholder for investigation operations
+     * TODO: Implement investigation-related methods
+     */
+    /**
+     * Builds the URL for the ISA data service.
+     *
+     * @param endpoint - the API endpoint path.
+     * @param params - optional query parameters as key-value pairs.
+     *
+     * @return complete URL with query string parameters.
+     */
+    private buildUrl;
+    getHealthCheck(): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ISADataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ISADataService>;
+}
+
+interface IsaDataServiceConfig {
+    baseUrl: string;
+}
+declare const ISA_DATA_SERVICE_CONFIG: InjectionToken<IsaDataServiceConfig>;
+
+interface VariantResults {
+    variantCount: number;
+    variants: Variant[];
+}
+interface Variant {
+    accession: string;
+    alt: string;
+    aminoAcidChange: string;
+    assembly: string;
+    canonVarIdentifier: {
+        caID: string;
+        id: number;
+        variantRefTxt: string;
+    };
+    chr: string;
+    dnaHgvsNotation: string;
+    functionalClassCode: string;
+    functionalClasses: SequenceOntologyTerm[];
+    gene: {
+        chr: string;
+        description: string;
+        ensemblGeneId: string;
+        entrezGeneId: string;
+        id: number;
+        mgiId: string;
+        name: string;
+        symbol: string;
+        synonyms: {
+            id: number;
+        }[];
+        transcripts: {
+            id: number;
+        }[];
+        type: string;
+    };
+    id: number;
+    impact: string;
+    parentRefInd: boolean;
+    position: number;
+    proteinHgvsNotation: string;
+    proteinPosition: string;
+    ref: string;
+    sources: {
+        id: number;
+        name: string;
+        sourceVersion: string;
+        url: string;
+    }[];
+    transcripts: {
+        description: string;
+        geneSymbol: string;
+        id: number;
+        mRnaId: string;
+        primaryIdentifier: string;
+    }[];
+    type: string;
+    variantHgvsNotation: string;
+    variantRefTxt: string;
+}
+interface SequenceOntologyTerm {
+    definition: string;
+    id: number;
+    label: string;
+    soId: string;
+    subClassOf: string;
+    mpdTerm: string;
+}
+interface SNP {
+    alternate_bases: string;
+    calls: Call[];
+    chr: string;
+    observed: string;
+    reference_base: string;
+    rs: string;
+    start_position: number | null;
+    annotation?: Variant | null;
+}
+interface Call {
+    strain_name: string;
+    sample_id: number;
+    genotype: string;
+    prob: number;
+    base: string;
+}
+interface SNPSearchRegion {
+    chromosome: string;
+    start_position: number;
+    end_position: number;
+    reference_base?: string;
+    alternate_base?: string;
+}
+declare const MUS_CHRS: string[];
+
+declare class MVarService {
+    private readonly config;
+    private readonly http;
+    private api;
+    sequenceOntologyMapping: Record<string, SequenceOntologyTerm>;
+    private soTerms;
+    soTerms$: Observable<SequenceOntologyTerm[]>;
+    constructor();
+    /**
+     * Gets Variants from mvar for a given set snp regions
+     * @param regions Array of snp regions
+     * @param pageStart snp start location
+     * @param pageEnd snp end location
+     * @param assembly Desired assembly version. Acceptable values are 'mm10' (GRCm38) and 'mm39' (GRCm39)
+     */
+    getVariants(regions: SNPSearchRegion[], pageStart: SNP, pageEnd: SNP, assembly: string): Observable<Variant[]>;
+    /**
+     * Returns all sequence ontology terms in MVAR
+     */
+    getSequenceOntologyTerms(): Observable<SequenceOntologyTerm[]>;
+    /**
+     * Translates the regions requested from MUSter and the regions actually displayed on the current page into
+     * regions to request from MVAR
+     * @param requestedRegions - regions included in the request to MUSter
+     * @param pageStart - first SNP from the sorted results from MUSter to display in the table
+     * @param pageEnd - last SNP from the sorted results from MUSter to display in the table
+     */
+    getRegionsToRequestVariantsFor(requestedRegions: SNPSearchRegion[], pageStart: SNP, pageEnd: SNP): SNPSearchRegion[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MVarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MVarService>;
+}
+
+declare class MvarClientModule {
+    static forRoot(apiUrl: string): ModuleWithProviders<MvarClientModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MvarClientModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MvarClientModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MvarClientModule>;
+}
+
+interface MVarServiceConfig {
+    apiUrl: string;
+}
+declare const MVAR_SERVICE_CONFIG: InjectionToken<MVarServiceConfig>;
+
+declare enum Ontology {
+    HP = "HP",
+    MONDO = "MONDO",
+    MP = "MP",
+    CL = "CL",
+    MAXO = "MAXO"
+}
+interface OntologyTerm {
+    id: string;
+    name: string;
+}
+interface OLSTerm {
+    appearsIn: string[];
+    curie: string;
+    definedBy: string[];
+    definition?: Array<{
+        type: string[];
+        value: string;
+        axioms?: Array<{
+            [key: string]: string;
+        }>;
+    }>;
+    definitionProperty?: string;
+    directAncestor?: string[];
+    directParent?: Array<string>;
+    hasDirectChildren?: boolean;
+    hasDirectParents?: boolean;
+    hasHierarchicalChildren?: boolean;
+    hasHierarchicalParents?: boolean;
+    hierarchicalAncestor?: string[];
+    hierarchicalParent?: Array<string | {
+        type: string[];
+        value: string;
+        axioms?: Array<{
+            [key: string]: string;
+        }>;
+    }>;
+    hierarchicalProperty?: string;
+    imported?: boolean;
+    iri: string;
+    isDefiningOntology?: boolean;
+    isObsolete?: boolean;
+    isPreferredRoot?: boolean;
+    label?: string[];
+    linkedEntities?: Record<string, any>;
+    linksTo?: string[];
+    numDescendants?: number;
+    numHierarchicalDescendants?: number;
+    ontologyId?: string;
+    ontologyIri?: string;
+    ontologyPreferredPrefix?: string;
+    searchableAnnotationValues?: any[];
+    shortForm?: string;
+    type?: string[];
+    [key: string]: any;
+}
+
+declare abstract class OntologyService {
+    abstract search(query: string, limit: number, ontology: Ontology): Observable<CollectionResponse<OntologyTerm>>;
+    abstract term(id: string): Observable<Response<OntologyTerm>>;
+    abstract parents(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    abstract children(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    abstract ancestors(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    abstract descendants(id: string): Observable<CollectionResponse<OntologyTerm>>;
+}
+
+declare class JaxOntologyService extends OntologyService {
+    private httpClient;
+    config_location: string;
+    private config;
+    /**
+     * Get the configuration file from the source for the backend api service
+     */
+    constructor();
+    /**
+     * Search for terms in an ontology
+     * @param query - the search query
+     * @param limit - the number of results to return
+     * @param ontology - the ontology to search
+     */
+    search(query: string, limit: number, ontology: Ontology): Observable<CollectionResponse<OntologyTerm>>;
+    /**
+     * Get a term by its ID
+     * @param id - the term ID
+     */
+    term(id: string): Observable<Response<OntologyTerm>>;
+    /**
+     * Get the parents of a term
+     * @param id - the term ID
+     */
+    parents(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    /**
+     * Get the children of a term
+     * @param id - the term ID
+     */
+    children(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    /**
+     * Get the ancestors of a term
+     * @param id - the term ID
+     */
+    ancestors(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    /**
+     * Get the descendants of a term
+     * @param id - the term ID
+     */
+    descendants(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    /**
+     * Get the ontology api base url configuration
+     **/
+    ontologyBaseResolver(ontology: Ontology): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JaxOntologyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JaxOntologyService>;
+}
+
+declare class OLSOntologyService extends OntologyService {
+    private httpClient;
+    private OLS_SEARCH_BASE;
+    private OLS_ENTITY_BASE;
+    private PURL_BASE;
+    constructor();
+    term(id: string): Observable<Response<OntologyTerm>>;
+    search(query: string, limit: number, ontology: Ontology): Observable<CollectionResponse<OntologyTerm>>;
+    parents(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    children(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    ancestors(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    descendants(id: string): Observable<CollectionResponse<OntologyTerm>>;
+    mapOLSTermToOntologyTerm(olsTerm: OLSTerm): OntologyTerm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OLSOntologyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OLSOntologyService>;
+}
+
+declare class SnpGridClientModule {
+    static forRoot(apiUrl: string): ModuleWithProviders<SnpGridClientModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnpGridClientModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SnpGridClientModule, never, [typeof i1.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SnpGridClientModule>;
+}
+
+interface MusterHealthCheck {
+    status: string;
+    timestamp: string;
+}
+interface MusterMetadata {
+    total_number_of_SNPs: number;
+    last_updated: string;
+    version: string;
+    total_number_of_strains: number;
+}
+interface Strain {
+    bq_sample_id: number;
+    mpd_strainid: number;
+    strainname: string;
+    straintype: string;
+}
+interface Gene {
+    symbol: string;
+    chr: string;
+    start_position: number;
+    end_position: number;
+    strand: string;
+    description: string;
+    mginum: string;
+    markertype: string;
+    centimorgan: number;
+    featuretype: string;
+}
+interface ReferenceSNP {
+    chr: string;
+    start_position: number;
+    end_position?: number;
+    rsid: string;
+}
+interface MusterSearchParameters {
+    bq_sample_ids: null;
+    genes: string | null;
+    genes_data: Gene[];
+    limit: number;
+    mpd_strain_ids: string;
+    next_region: string | null;
+    offset: number;
+    query_regions: {
+        chromosome: string;
+        regions: SNPSearchRegion[];
+    }[];
+    regions: SNPSearchRegion[];
+    rsids: string | null;
+    rsids_data: ReferenceSNP[];
+    strain_limit: number;
+    strain_names: null;
+    dataset: Dataset;
+}
+interface SNPSearchProperties {
+    strains: number[];
+    strains_b?: number[];
+    rsids?: string[];
+    regions?: string[];
+    assembly: string;
+    genes?: string[];
+    offset?: number;
+    dataset_id?: number;
+    is_unique_row?: boolean;
+}
+interface GenotypeResults {
+    message: string | null;
+    next_region: string;
+    parameter: MusterSearchParameters;
+    snps: SNP[];
+    status: string;
+    total_rows: number;
+}
+declare enum DatasetStatus {
+    Queued = "queued",
+    Loading = "loading",
+    Done = "done",
+    Archived = "archived"
+}
+interface Dataset {
+    id: number;
+    display_name: string;
+    sort_by: number;
+    year: string;
+    procedure: string;
+    panel: string;
+    sex: string;
+    dataset_name: string;
+    source: string;
+    status: DatasetStatus;
+    num_of_strains: number;
+    pubmed: string;
+    description: string;
+    assembly_version: string;
+}
+
+declare class SnpGridService {
+    private readonly config;
+    private readonly http;
+    private api;
+    constructor();
+    /**
+     * Returns the result of a health check for the API
+     */
+    getHealthCheck(): Observable<MusterHealthCheck>;
+    /**
+     * Returns the metadata on the MUSter DB
+     */
+    getMusterMetadata(): Observable<MusterMetadata>;
+    /**
+     * Returns strains available in the API and takes an optional limit; by default the limit is set
+     * to 5000 to get all strains
+     * @param limit - maximum number of strains to be returned
+     */
+    getStrains(limit?: number): Observable<Strain[]>;
+    /**
+     * Returns a list of known genes whose symbols/coordinates start with the specified value.
+     * @param searchValue - value to use for the "starts with" filter
+     * @param limit - maximum number of genes to return, default is 20
+     */
+    getGenes(searchValue: string, limit?: number): Observable<Gene[]>;
+    /**
+     * Returns the gene that matches the specified gene symbol
+     * @param geneSymbol - symbol to use to get the associated gene info
+     */
+    getGene(geneSymbol: string): Observable<Gene | null>;
+    /**
+     * Returns true if the specified gene symbol is valid from the perspective of MUSter
+     * @param geneSymbol - symbol to use to check the validity of
+     */
+    isGeneSymbolValid(geneSymbol: string): Observable<boolean>;
+    /**
+     * Returns list of known reference SNP (RS) data which includes IDs and coordinates
+     * @param searchValue - value to use to filter the search results
+     * @param limit - maximum number of results to return, default is 20
+     */
+    getReferenceSNPs(searchValue: string, limit?: number): Observable<ReferenceSNP[]>;
+    /**
+     * Returns the RS info that matches the specified rsID
+     * @param rsid - the RSID to use to get the associated RS info
+     */
+    getReferenceSNP(rsid: string): Observable<ReferenceSNP | null>;
+    /**
+     * Returns true if the specified rsID is valid from the perspective of MUSter
+     * @param rsid - rsID to use to check the validity of
+     */
+    isRSIDValid(rsid: string): Observable<boolean>;
+    /**
+     * Returns the SNP results generated from the query constructed from the specified parameters and page
+     * @param parameters - search properties (strain IDs, regions, assembly version, etc.)
+     * @param page - requested page, which is 0-indexed. The 0th page is the initial page
+     * @param pageSize - number of records to show per page. Default of 5000
+     */
+    getGenotypes(parameters: SNPSearchProperties, page?: number, pageSize?: number): Observable<GenotypeResults>;
+    /**
+     * Returns the URL that will generate a download (in file form) for the specified strain IDs and regions
+     * @param strains - list of mpd_strain_ids to query SNPs for
+     * @param regions - list of SNPSearchRegions to query SNPs for (chromosome, start and end)
+     * @param dataset_id - ID of the dataset to query SNPs for
+     * @param is_unique_row - boolean for polymorphism filtering - true for only rows with polymorphism, false for all
+     * @param limit - the limit of the number of result rows to include in the download - you're likely to
+     *                prefer to pass the total number of rows generated by the query itself, which is included
+     *                as part of the GenotypeResults returned by getGenotypes()
+     */
+    getGenotypeDownloadURLForCurrentData(strains: number[], regions: SNPSearchRegion[], dataset_id: number | undefined, is_unique_row: boolean | undefined, limit: number): string;
+    /**
+     * Returns the dataset with the given ID
+     * @param id
+     */
+    getDataset(id: number): Observable<Dataset>;
+    /**
+     * Returns a list of Datasets that match the given criteria
+     * @param status  The value of the status to be used for filtering
+     * @param limit   The maximum number of records to return
+     */
+    findDatasets(status: DatasetStatus, limit?: number): Observable<Dataset[]>;
+    /**
+     * Return a list of strains that match the given criteria
+     * @param datasetId  The ID of the dataset from which to fetch the strains
+     * @param limit      The maximum number of records to return
+     */
+    datasetStrains(datasetId: number, limit?: number): Observable<Strain[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnpGridService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SnpGridService>;
+}
+
+interface SnpGridServiceConfig {
+    apiUrl: string;
+}
+declare const SNP_GRID_SERVICE_CONFIG: InjectionToken<SnpGridServiceConfig>;
+
+export { AsyncTaskService, DatasetStatus, ISADataService, ISA_DATA_SERVICE_CONFIG, JaxOntologyService, MUS_CHRS, MVAR_SERVICE_CONFIG, MVarService, MvarClientModule, OLSOntologyService, OntologyService, SNP_GRID_SERVICE_CONFIG, SnpGridClientModule, SnpGridService, WorkflowExecutionStatus };
+export type { Call, Dataset, Gene, GenotypeResults, Input, InputReference, InputSubmission, IsaCharacteristic, IsaCharacteristicValue, IsaDataServiceConfig, MVarServiceConfig, Measure, MeasureMetadata, MeasureSeries, MeasureSeriesMetadata, MeasureValue, MusterHealthCheck, MusterMetadata, MusterSearchParameters, ReferenceSNP, Result, ResultReference, Run, SNP, SNPSearchProperties, SNPSearchRegion, SequenceOntologyTerm, SnpGridServiceConfig, Strain, Variant, VariantResults };