
import * as _tanstack_react_query4 from "@tanstack/react-query";
import { AxiosInstance } from "axios";

//#region src/api/info.d.ts
/**
 * Column-level data for a node
 */
interface NodeColumnData {
  name: string;
  type: string;
  transformation_type?: string;
  change_status?: "added" | "removed" | "modified";
  not_null?: boolean;
  unique?: boolean;
}
/**
 * Node data within lineage
 */
interface NodeData {
  id: string;
  unique_id: string;
  name: string;
  schema?: string;
  checksum?: {
    name: string;
    checksum: string;
  };
  raw_code?: string;
  resource_type?: string;
  package_name?: string;
  columns?: Record<string, NodeColumnData | undefined>;
  primary_key?: string;
}
/**
 * dbt artifact metadata
 * @see https://docs.getdbt.com/reference/artifacts/dbt-artifacts#common-metadata
 */
interface ArtifactMetadata {
  dbt_version: string;
  dbt_schema_version: string;
  generated_at: string;
  adapter_type: string;
  env: Record<string, string>;
  invocation_id: string;
}
/**
 * Manifest metadata extends artifact metadata
 */
interface ManifestMetadata extends ArtifactMetadata {
  project_id?: string;
  project_name?: string;
  user_id?: string;
}
/**
 * SQLMesh environment info
 */
interface SQLMeshInfo {
  base_env: string;
  current_env: string;
}
type CatalogMetadata = ArtifactMetadata;
/**
 * Lineage data structure
 */
interface LineageData {
  metadata: {
    pr_url: string;
    git_branch?: string;
  };
  nodes: Record<string, NodeData>;
  parent_map: Record<string, string[]>;
  manifest_metadata?: ManifestMetadata | null;
  catalog_metadata?: CatalogMetadata | null;
}
interface LineageDataFromMetadata extends Omit<LineageData, "nodes"> {
  nodes: Record<string, NodeData | undefined>;
}
/**
 * Lineage diff data
 */
type LineageDiffData = Record<string, {
  change_status: "added" | "removed" | "modified";
  change: {
    category: "breaking" | "non_breaking" | "partial_breaking" | "unknown";
    columns: Record<string, "added" | "removed" | "modified"> | null;
  } | null;
}>;
/**
 * Lineage diff result from lineage_diff run type
 */
interface LineageDiffResult {
  base?: LineageData;
  current?: LineageData;
  base_error?: string;
  current_error?: string;
}
/**
 * State metadata for recce state file
 */
interface StateMetadata {
  schema_version: string;
  recce_version: string;
  generated_at: string;
}
/**
 * Git information
 */
interface GitInfo {
  branch?: string;
}
/**
 * Pull request information
 */
interface PullRequestInfo {
  id?: string | number;
  title?: string;
  url?: string;
  branch?: string;
  base_branch?: string;
}
/**
 * Server info result from /api/info endpoint
 */
interface ServerInfoResult {
  state_metadata: StateMetadata;
  adapter_type: string;
  review_mode: boolean;
  cloud_mode: boolean;
  file_mode: boolean;
  filename?: string;
  git?: GitInfo;
  pull_request?: PullRequestInfo;
  sqlmesh?: SQLMeshInfo;
  lineage: {
    base: LineageData;
    current: LineageData;
    diff: LineageDiffData;
  };
  demo: boolean;
  codespace: boolean;
  support_tasks: Record<string, boolean>;
}
/**
 * Fetch server info from API
 */
declare function getServerInfo(client: AxiosInstance): Promise<ServerInfoResult>;
/**
 * Model info result from /api/model/:model endpoint
 */
interface ModelInfoResult {
  model: {
    base: {
      columns?: Record<string, NodeColumnData>;
      primary_key?: string;
    };
    current: {
      columns?: Record<string, NodeColumnData>;
      primary_key?: string;
    };
  };
}
/**
 * Fetch model info (columns and primary key) from API
 */
declare function getModelInfo(model: string, client: AxiosInstance): Promise<ModelInfoResult>;
//#endregion
//#region src/api/cll.d.ts
interface CllInput {
  node_id?: string;
  column?: string;
  change_analysis?: boolean;
  no_cll?: boolean;
  no_upstream?: boolean;
  no_downstream?: boolean;
}
interface ImpactRadiusParams {
  node_id: string;
}
interface CllNodeData {
  id: string;
  name: string;
  source_name: string;
  resource_type: string;
  raw_code?: string;
  change_status?: "added" | "removed" | "modified";
  change_category?: "breaking" | "non_breaking" | "partial_breaking" | "unknown";
  impacted?: boolean;
  columns?: Record<string, NodeColumnData>;
}
interface ColumnLineageData {
  current: {
    nodes: Record<string, CllNodeData>;
    columns: Record<string, NodeColumnData>;
    /** JSON arrays from API - iterable like Set but properly typed */
    parent_map: Record<string, string[]>;
    /** JSON arrays from API - iterable like Set but properly typed */
    child_map: Record<string, string[]>;
  };
}
/**
 * Get column-level lineage data.
 *
 * @param input - CLL input parameters
 * @param client - Axios instance for API configuration
 * @returns Promise resolving to column lineage data
 */
declare function getCll(input: CllInput, client: AxiosInstance): Promise<ColumnLineageData>;
//#endregion
//#region src/api/types/base.d.ts
/**
 * Query parameters for Axios requests
 * Supports string, number, and array values with undefined for optional params
 */
type AxiosQueryParams = Record<string, string | string[] | number | number[] | undefined>;
/**
 * Primitive data types that can appear in a row
 */
type RowDataTypes = number | string | boolean | null | undefined;
/**
 * A single row of data represented as an array of primitive values
 */
type RowData = RowDataTypes[];
/**
 * A row of data represented as an object with named columns
 * Includes metadata for diff status and optional index
 */
type RowObjectType = Record<string, RowDataTypes> & {
  __status: "added" | "removed" | "modified" | undefined;
  _index?: number;
};
/**
 * Supported column data types for schema and display purposes
 */
type ColumnType = "number" | "integer" | "text" | "boolean" | "date" | "datetime" | "timedelta" | "unknown";
/**
 * Column rendering modes for display formatting
 * - raw: display value as-is
 * - percent: display as percentage
 * - delta: display as delta/change value
 * - 2: display with 2 decimal places
 */
type ColumnRenderMode = "raw" | "percent" | "delta" | 2;
/**
 * A DataFrame represents tabular data with typed columns
 * Used for query results, profile data, and other tabular responses
 */
interface DataFrame {
  columns: {
    key: string;
    name: string;
    type: ColumnType;
  }[];
  data: RowData[];
  /** Maximum number of rows requested */
  limit?: number;
  /** Whether more rows are available beyond the limit */
  more?: boolean;
}
//#endregion
//#region src/api/runs.d.ts
/**
 * Aggregated run results by model and run type
 */
type RunsAggregated = Record<string, Record<"row_count_diff" | "value_diff" | "row_count", {
  run_id: string;
  result: unknown;
}>>;
/**
 * Properties for tracking run submissions (analytics)
 */
interface SubmitRunTrackProps {
  breaking_change_analysis?: boolean;
  source?: "lineage_model_node" | "lineage_column_node";
  [key: string]: unknown;
}
/**
 * Options for submitting a run
 */
interface SubmitOptions {
  nowait?: boolean;
  trackProps?: SubmitRunTrackProps;
}
/**
 * Submit a new run of the specified type.
 * @param type - The type of run to execute
 * @param params - Parameters specific to the run type
 * @param options - Submission options (nowait, tracking)
 * @param client - Required axios instance (no default - library pattern)
 * @returns The created run, or just run_id if nowait is true
 */
declare function submitRun(type: RunType, params: unknown, options: SubmitOptions | undefined, client: AxiosInstance): Promise<Run | Pick<Run, "run_id">>;
/**
 * Get a run by ID.
 * @param runId - The ID of the run to retrieve
 * @param client - Required axios instance
 * @returns The run object
 */
declare function getRun(runId: string, client: AxiosInstance): Promise<Run>;
/**
 * Wait for a run to complete.
 * @param runId - The ID of the run to wait for
 * @param timeout - Optional timeout in seconds
 * @param client - Required axios instance
 * @returns The completed run object with result
 */
declare function waitRun(runId: string, timeout: number | undefined, client: AxiosInstance): Promise<Run>;
/**
 * Cancel a running run.
 * @param runId - The ID of the run to cancel
 * @param client - Required axios instance
 */
declare function cancelRun(runId: string, client: AxiosInstance): Promise<void>;
/**
 * Submit a run from an existing check.
 * Re-runs the check with its stored parameters.
 * @param checkId - The ID of the check to run
 * @param options - Submission options (nowait)
 * @param client - Required axios instance
 * @returns The created run, or just run_id if nowait is true
 */
declare function submitRunFromCheck(checkId: string, options: SubmitOptions | undefined, client: AxiosInstance): Promise<Run | Pick<Run, "run_id">>;
/**
 * Search for runs matching criteria.
 * @param type - The run type to search for
 * @param params - Parameters to match against run params
 * @param limit - Maximum number of results to return
 * @param client - Required axios instance
 * @returns Array of matching runs
 */
declare function searchRuns(type: string, params: Record<string, unknown> | undefined, limit: number | undefined, client: AxiosInstance): Promise<Run[]>;
/**
 * List all runs.
 * @param client - Required axios instance
 * @returns Array of all runs
 */
declare function listRuns(client: AxiosInstance): Promise<Run[]>;
/**
 * Aggregate runs from API.
 * Returns run results grouped by model and run type.
 * @param client - Required axios instance
 * @returns Aggregated run results
 */
declare function aggregateRuns(client: AxiosInstance): Promise<RunsAggregated>;
//#endregion
//#region src/api/adhocQuery.d.ts
interface QueryRunParams {
  sql_template: string;
}
type QueryResult = DataFrame;
interface QueryViewOptions {
  pinned_columns?: string[];
  columnsRenderMode?: Record<string, ColumnRenderMode>;
}
interface QueryDiffParams {
  sql_template: string;
  base_sql_template?: string;
  primary_keys?: string[];
}
interface QueryDiffResult {
  base?: DataFrame;
  current?: DataFrame;
  diff?: DataFrame;
}
interface QueryDiffViewOptions {
  changed_only?: boolean;
  primary_keys?: string[];
  pinned_columns?: string[];
  display_mode?: "inline" | "side_by_side";
  columnsRenderMode?: Record<string, ColumnRenderMode>;
}
interface QueryPreviewChangeParams {
  current_model?: string;
  sql_template: string;
  primary_keys?: string[];
}
interface QueryParams extends QueryRunParams, QueryDiffParams, QueryPreviewChangeParams {}
declare function submitQuery(params: QueryRunParams, options: SubmitOptions | undefined, client: AxiosInstance): Promise<Run | Pick<Run, "run_id">>;
declare function submitQueryBase(params: QueryRunParams, options: SubmitOptions | undefined, client: AxiosInstance): Promise<Run | Pick<Run, "run_id">>;
declare function submitQueryDiff(params: QueryDiffParams, options: SubmitOptions | undefined, client: AxiosInstance): Promise<Run | Pick<Run, "run_id">>;
//#endregion
//#region src/api/profile.d.ts
interface ProfileDiffParams {
  model: string;
  columns?: string[];
}
interface ProfileDiffResult {
  base?: DataFrame;
  current?: DataFrame;
}
interface ProfileDiffViewOptions {
  pinned_columns?: string[];
  display_mode?: "side_by_side" | "inline";
  columnsRenderMode?: Record<string, ColumnRenderMode>;
}
declare function submitProfileDiff(params: ProfileDiffParams, options: SubmitOptions | undefined, client: AxiosInstance): Promise<Run | Pick<Run, "run_id">>;
interface TopKDiffParams {
  model: string;
  column_name: string;
  k: number;
}
interface TopKResult {
  values: (string | number | undefined)[];
  counts: number[];
  valids: number;
}
interface TopKDiffResult {
  base: TopKResult;
  current: TopKResult;
}
/**
 * View options for TopKDiffResultView.
 * Controls display preferences for top-K diff visualization.
 */
interface TopKViewOptions {
  /**
   * When true, show all items instead of just top 10.
   * Default is false (show top 10 only).
   */
  show_all?: boolean;
}
interface HistogramDiffParams {
  model: string;
  column_name: string;
  column_type: string;
}
interface HistogramResult {
  counts: number[];
  total: number;
}
interface HistogramDiffResult {
  base: HistogramResult;
  current: HistogramResult;
  min: number;
  max: number;
  bin_edges: number[];
  labels?: string[];
}
//#endregion
//#region src/api/rowcount.d.ts
interface RowCountParams {
  node_names: string[];
}
interface RowCount {
  name?: string;
  curr: number | null;
}
type RowCountResult = Record<string, RowCount>;
interface RowCountDiffParams {
  node_names: string[];
}
interface RowCountDiff {
  name?: string;
  base: number | null;
  curr: number | null;
}
type RowCountDiffResult = Record<string, RowCountDiff>;
declare function submitRowCountDiff(params: RowCountDiffParams, options: SubmitOptions | undefined, client: AxiosInstance): Promise<Run | Pick<Run, "run_id">>;
//#endregion
//#region src/api/valuediff.d.ts
interface ValueDiffParams {
  model: string;
  primary_key: string | string[];
  columns?: string[];
}
interface ValueDiffResult {
  summary: {
    total: number;
    added: number;
    removed: number;
  };
  data: DataFrame;
}
type ValueDiffDetailParams = ValueDiffParams;
type ValueDiffDetailResult = DataFrame;
interface ValueDiffDetailViewOptions {
  changed_only?: boolean;
  pinned_columns?: string[];
  display_mode?: "inline" | "side_by_side";
  columnsRenderMode?: Record<string, ColumnRenderMode>;
}
declare function submitValueDiff(params: ValueDiffParams, options: SubmitOptions | undefined, client: AxiosInstance): Promise<Run | Pick<Run, "run_id">>;
declare function submitValueDiffDetail(params: ValueDiffParams, options: SubmitOptions | undefined, client: AxiosInstance): Promise<Run | Pick<Run, "run_id">>;
//#endregion
//#region src/api/types/run.d.ts
/**
 * All possible run types in the Recce system.
 * This is the canonical definition - consumers should import from here.
 */
type RunType = "simple" | "sandbox" | "query" | "query_base" | "query_diff" | "value_diff" | "value_diff_detail" | "schema_diff" | "profile" | "profile_diff" | "row_count" | "row_count_diff" | "lineage_diff" | "top_k_diff" | "histogram_diff";
/**
 * Possible status values for a run
 */
type RunStatus = "Finished" | "Failed" | "Cancelled" | "Running";
/**
 * Progress information for a running task
 */
interface RunProgress {
  message?: string;
  percentage?: number;
}
/**
 * Base interface for all run objects.
 * All run variants extend this interface with specific params and results.
 */
interface BaseRun {
  /** The type of run - determines params/result structure */
  type: RunType;
  /** Unique identifier for this run */
  run_id: string;
  /** ISO timestamp when the run was executed */
  run_at: string;
  /** Optional human-readable name for the run */
  name?: string;
  /** ID of the check this run belongs to, if any */
  check_id?: string;
  /** Progress information for running tasks */
  progress?: RunProgress;
  /** Error message if the run failed */
  error?: string;
  /** Current status of the run */
  status?: RunStatus;
}
/**
 * Schema diff params - used by schema_diff runs
 * Compares schema between base and current environments
 */
interface SchemaDiffParams {
  /** Node ID(s) to compare - can be single or multiple */
  node_id?: string | string[];
  /** dbt select syntax for filtering nodes */
  select?: string;
  /** dbt exclude syntax for filtering nodes */
  exclude?: string;
  /** Package names to include */
  packages?: string[];
  /** View mode - show all models or only changed ones */
  view_mode?: "all" | "changed_models";
}
/**
 * Lineage diff params - used by lineage_diff runs
 * Compares lineage graph between base and current environments
 */
interface LineageDiffParams {
  /** dbt select syntax for filtering nodes */
  select?: string;
  /** dbt exclude syntax for filtering nodes */
  exclude?: string;
  /** Package names to include */
  packages?: string[];
  /** View mode - show all models or only changed ones */
  view_mode?: "all" | "changed_models";
}
/**
 * Union of all possible run parameter types.
 * Use this when you need to accept any run params type.
 */
type RunParamTypes = QueryRunParams | QueryDiffParams | ValueDiffParams | ValueDiffDetailParams | SchemaDiffParams | ProfileDiffParams | RowCountParams | RowCountDiffParams | LineageDiffParams | TopKDiffParams | HistogramDiffParams | undefined;
/**
 * Run type with full discriminated union for type narrowing.
 * TypeScript can narrow params/result types based on the `type` field.
 *
 * Example:
 * ```ts
 * if (run.type === "query_diff") {
 *   // TypeScript knows run.result is QueryDiffResult | undefined
 *   console.log(run.result?.diff);
 * }
 * ```
 */
type Run = (BaseRun & {
  type: "simple";
  params?: undefined;
  result?: undefined;
}) | (BaseRun & {
  type: "sandbox";
  params?: undefined;
  result?: undefined;
}) | (BaseRun & {
  type: "query";
  params?: QueryRunParams;
  result?: QueryResult;
}) | (BaseRun & {
  type: "query_base";
  params?: QueryRunParams;
  result?: QueryResult;
}) | (BaseRun & {
  type: "query_diff";
  params?: QueryDiffParams;
  result?: QueryDiffResult;
}) | (BaseRun & {
  type: "value_diff";
  params?: ValueDiffParams;
  result?: ValueDiffResult;
}) | (BaseRun & {
  type: "value_diff_detail";
  params?: ValueDiffDetailParams;
  result?: ValueDiffDetailResult;
}) | (BaseRun & {
  type: "schema_diff";
  params?: SchemaDiffParams;
  result?: undefined;
}) | (BaseRun & {
  type: "profile";
  params?: ProfileDiffParams;
  result?: ProfileDiffResult;
}) | (BaseRun & {
  type: "profile_diff";
  params?: ProfileDiffParams;
  result?: ProfileDiffResult;
}) | (BaseRun & {
  type: "row_count";
  params?: RowCountParams;
  result?: RowCountResult;
}) | (BaseRun & {
  type: "row_count_diff";
  params?: RowCountDiffParams;
  result?: RowCountDiffResult;
}) | (BaseRun & {
  type: "lineage_diff";
  params?: LineageDiffParams;
  result?: LineageDiffResult;
}) | (BaseRun & {
  type: "top_k_diff";
  params?: TopKDiffParams;
  result?: TopKDiffResult;
}) | (BaseRun & {
  type: "histogram_diff";
  params?: HistogramDiffParams;
  result?: HistogramDiffResult;
});
/**
 * Type guard for simple runs
 */
declare function isSimpleRun(run: Run): run is Run & {
  type: "simple";
};
/**
 * Type guard for sandbox runs
 */
declare function isSandboxRun(run: Run): run is Run & {
  type: "sandbox";
};
/**
 * Type guard for query runs
 */
declare function isQueryRun(run: Run): run is Run & {
  type: "query";
};
/**
 * Type guard for query_base runs
 */
declare function isQueryBaseRun(run: Run): run is Run & {
  type: "query_base";
};
/**
 * Type guard for query_diff runs
 */
declare function isQueryDiffRun(run: Run): run is Run & {
  type: "query_diff";
};
/**
 * Type guard for value_diff runs
 */
declare function isValueDiffRun(run: Run): run is Run & {
  type: "value_diff";
};
/**
 * Type guard for value_diff_detail runs
 */
declare function isValueDiffDetailRun(run: Run): run is Run & {
  type: "value_diff_detail";
};
/**
 * Type guard for schema_diff runs
 */
declare function isSchemaDiffRun(run: Run): run is Run & {
  type: "schema_diff";
};
/**
 * Type guard for profile runs
 */
declare function isProfileRun(run: Run): run is Run & {
  type: "profile";
};
/**
 * Type guard for profile_diff runs
 */
declare function isProfileDiffRun(run: Run): run is Run & {
  type: "profile_diff";
};
/**
 * Type guard for row_count runs
 */
declare function isRowCountRun(run: Run): run is Run & {
  type: "row_count";
};
/**
 * Type guard for row_count_diff runs
 */
declare function isRowCountDiffRun(run: Run): run is Run & {
  type: "row_count_diff";
};
/**
 * Type guard for lineage_diff runs
 */
declare function isLineageDiffRun(run: Run): run is Run & {
  type: "lineage_diff";
};
/**
 * Type guard for top_k_diff runs
 */
declare function isTopKDiffRun(run: Run): run is Run & {
  type: "top_k_diff";
};
/**
 * Type guard for histogram_diff runs
 */
declare function isHistogramDiffRun(run: Run): run is Run & {
  type: "histogram_diff";
};
/**
 * Array of all run type values - useful for iteration and validation
 */
declare const RUN_TYPES: readonly RunType[];
/**
 * Check if a string is a valid RunType
 */
declare function isValidRunType(value: string): value is RunType;
/**
 * Check if a run type supports ref forwarding (for screenshots).
 * Run types with refs can capture screenshots of their result views.
 */
declare function runTypeHasRef(runType: RunType): boolean;
//#endregion
//#region src/api/checks.d.ts
/**
 * A check object representing a saved validation check.
 * @template PT - The type of params for this check
 * @template VO - The type of view options for this check
 */
interface Check<PT = unknown, VO = unknown> {
  check_id: string;
  name: string;
  description?: string;
  type: RunType;
  params?: PT;
  view_options?: VO;
  is_checked?: boolean;
  is_preset?: boolean;
  last_run?: Run;
}
/**
 * Request body for creating a new check.
 */
interface CreateCheckBody {
  name?: string;
  description?: string;
  run_id?: string;
  type?: RunType;
  params?: Record<string, unknown>;
  view_options?: Record<string, unknown>;
  track_props?: Record<string, unknown>;
}
/**
 * Create a simple check (no run association).
 * @param client - Required axios instance
 * @returns The created check
 */
declare function createSimpleCheck(client: AxiosInstance): Promise<Check>;
/**
 * Create a check from an existing run.
 * @param runId - The ID of the run to create a check from
 * @param viewOptions - Optional view options for the check
 * @param client - Required axios instance
 * @returns The created check
 */
declare function createCheckByRun(runId: string, viewOptions: Record<string, unknown> | undefined, client: AxiosInstance): Promise<Check>;
/**
 * List all checks.
 * @param client - Required axios instance
 * @returns Array of all checks
 */
declare function listChecks(client: AxiosInstance): Promise<Check[]>;
/**
 * Get a check by ID.
 * @param checkId - The ID of the check to retrieve
 * @param client - Required axios instance
 * @returns The check object
 */
declare function getCheck(checkId: string, client: AxiosInstance): Promise<Check>;
/**
 * Update an existing check.
 * @param checkId - The ID of the check to update
 * @param payload - Partial check data to update
 * @param client - Required axios instance
 * @returns The updated check
 */
declare function updateCheck(checkId: string, payload: Partial<Check>, client: AxiosInstance): Promise<Check>;
/**
 * Delete a check.
 * @param checkId - The ID of the check to delete
 * @param client - Required axios instance
 * @returns The deleted check ID
 */
declare function deleteCheck(checkId: string, client: AxiosInstance): Promise<Pick<Check, "check_id">>;
/**
 * Reorder checks.
 * @param order - Source and destination indices
 * @param client - Required axios instance
 */
declare function reorderChecks(order: {
  source: number;
  destination: number;
}, client: AxiosInstance): Promise<void>;
/**
 * Mark a check as a preset check.
 * @param checkId - The ID of the check to mark as preset
 * @param client - Required axios instance
 */
declare function markAsPresetCheck(checkId: string, client: AxiosInstance): Promise<void>;
/**
 * Hook to fetch and cache the list of checks.
 * Can be used outside RecceProvider with a fallback to default axios client.
 *
 * @param enabled - Whether the query should be enabled
 * @returns TanStack Query result with checks data
 */
declare function useChecks(enabled: boolean): _tanstack_react_query4.UseQueryResult<Check<unknown, unknown>[], Error>;
//#endregion
//#region src/api/lineagecheck.d.ts
interface LineageDiffViewOptions {
  view_mode?: "changed_models" | "all";
  node_ids?: string[];
  packages?: string[];
  select?: string;
  exclude?: string;
  column_level_lineage?: CllInput;
}
/**
 * Create a lineage diff check.
 *
 * @param viewOptions - View options for the lineage diff
 * @param client - Axios instance for API configuration
 * @returns Promise resolving to the created check
 */
declare function createLineageDiffCheck(viewOptions: LineageDiffViewOptions, client: AxiosInstance): Promise<Check>;
//#endregion
//#region src/api/flag.d.ts
/**
 * Server-side feature flags
 */
interface RecceServerFlags {
  single_env_onboarding: boolean;
  show_relaunch_hint: boolean;
}
/**
 * Fetch server flags from API
 */
declare function getServerFlag(client: AxiosInstance): Promise<RecceServerFlags>;
/**
 * Mark relaunch hint as completed
 */
declare function markRelaunchHintCompleted(client: AxiosInstance): Promise<void>;
//#endregion
//#region src/api/instanceInfo.d.ts
/**
 * Server mode for the Recce instance.
 * - "server": Full read-write mode
 * - "preview": Metadata only mode (no database queries)
 * - "read-only": Read-only mode (no modifications allowed)
 */
type ServerMode = "server" | "preview" | "read-only";
/**
 * Information about the Recce instance returned from the server.
 */
interface RecceInstanceInfo {
  server_mode: ServerMode;
  single_env: boolean;
  authed: boolean;
  cloud_instance: boolean;
  lifetime_expired_at?: Date;
  idle_timeout?: number;
  share_url?: string;
  session_id?: string;
  organization_name?: string;
  web_url?: string;
}
/**
 * Fetches instance information from the Recce server.
 *
 * @param client - Axios instance to use for the request
 * @returns Promise resolving to RecceInstanceInfo
 */
declare function getRecceInstanceInfo(client: AxiosInstance): Promise<RecceInstanceInfo>;
//#endregion
export { RowCount as $, LineageData as $t, isLineageDiffRun as A, SubmitRunTrackProps as At, isSimpleRun as B, ColumnRenderMode as Bt, Run as C, QueryRunParams as Ct, RunType as D, submitQueryDiff as Dt, RunStatus as E, submitQueryBase as Et, isQueryRun as F, searchRuns as Ft, runTypeHasRef as G, RowObjectType as Gt, isValidRunType as H, DataFrame as Ht, isRowCountDiffRun as I, submitRun as It, ValueDiffDetailViewOptions as J, ColumnLineageData as Jt, ValueDiffDetailParams as K, CllInput as Kt, isRowCountRun as L, submitRunFromCheck as Lt, isProfileRun as M, cancelRun as Mt, isQueryBaseRun as N, getRun as Nt, SchemaDiffParams as O, RunsAggregated as Ot, isQueryDiffRun as P, listRuns as Pt, submitValueDiffDetail as Q, GitInfo as Qt, isSandboxRun as R, waitRun as Rt, RUN_TYPES as S, QueryResult as St, RunProgress as T, submitQuery as Tt, isValueDiffDetailRun as U, RowData as Ut, isTopKDiffRun as V, ColumnType as Vt, isValueDiffRun as W, RowDataTypes as Wt, ValueDiffResult as X, getCll as Xt, ValueDiffParams as Y, ImpactRadiusParams as Yt, submitValueDiff as Z, CatalogMetadata as Zt, reorderChecks as _, QueryDiffParams as _t, getServerFlag as a, NodeColumnData as an, submitRowCountDiff as at, BaseRun as b, QueryParams as bt, createLineageDiffCheck as c, SQLMeshInfo as cn, HistogramResult as ct, createCheckByRun as d, getModelInfo as dn, ProfileDiffViewOptions as dt, LineageDataFromMetadata as en, RowCountDiff as et, createSimpleCheck as f, getServerInfo as fn, TopKDiffParams as ft, markAsPresetCheck as g, submitProfileDiff as gt, listChecks as h, TopKViewOptions as ht, RecceServerFlags as i, ModelInfoResult as in, RowCountResult as it, isProfileDiffRun as j, aggregateRuns as jt, isHistogramDiffRun as k, SubmitOptions as kt, Check as l, ServerInfoResult as ln, ProfileDiffParams as lt, getCheck as m, TopKResult as mt, ServerMode as n, LineageDiffResult as nn, RowCountDiffResult as nt, markRelaunchHintCompleted as o, NodeData as on, HistogramDiffParams as ot, deleteCheck as p, TopKDiffResult as pt, ValueDiffDetailResult as q, CllNodeData as qt, getRecceInstanceInfo as r, ManifestMetadata as rn, RowCountParams as rt, LineageDiffViewOptions as s, PullRequestInfo as sn, HistogramDiffResult as st, RecceInstanceInfo as t, LineageDiffData as tn, RowCountDiffParams as tt, CreateCheckBody as u, StateMetadata as un, ProfileDiffResult as ut, updateCheck as v, QueryDiffResult as vt, RunParamTypes as w, QueryViewOptions as wt, LineageDiffParams as x, QueryPreviewChangeParams as xt, useChecks as y, QueryDiffViewOptions as yt, isSchemaDiffRun as z, AxiosQueryParams as zt };
//# sourceMappingURL=instanceInfo-D9Pe6gIo.d.ts.map