import { CodeComponentMeta } from '@plasmicapp/host/registerComponent';
import { PlasmicDataSourceContextValue } from '@plasmicapp/data-sources-context';
import { default as React_2 } from 'react';
import { usePlasmicDataConfig } from '@plasmicapp/query';

declare interface $StateSpec<T = any> {
    path: string;
    initFunc?: (env: QueryExecutionContext & {
        /** @deprecated This field is here to conform to react-web's $StateSpec. */
        $queries: Record<string, any>;
        /** @deprecated This field is here to conform to react-web's $StateSpec. */
        $refs: Record<string, any>;
    }) => T;
    initVal?: T;
    type: "private" | "readonly" | "writable";
    valueProp?: string;
}

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare type BaseFieldConfig = {
    key?: string;
    fieldId?: string;
};

/**
 * Initial context just before execution.
 * @internal
 */
declare type ClientQueryExecutionContext = Pick<QueryExecutionContext, "$ctx" | "$props"> & {
    $state: QueryExecutionContext["$state"] | null;
};

/**
 * Represents the result of a client-side query.
 * @deprecated See https://docs.plasmic.app/learn/integrations
 */
export declare interface ClientQueryResult<T = any> {
    /**
     * The data returned by the query. May be undefined if the query has not yet completed.
     */
    data?: T;
    /**
     * The schema of the table from which the data was queried. Only available for plasmic data
     * integration. May be undefined if the query has not yet completed.
     */
    schema?: TableSchema;
    /**
     * The total number of records available. Only available for plasmic data integration. May be
     * undefined if the query has not yet completed.
     */
    total?: number;
    /**
     * Pagination information for the query result. Only available for plasmic data integration. May be
     * undefined if the query has not yet completed.
     */
    paginate?: Pagination;
    /**
     * Any error that occurred during the query. This is optional and may be undefined.
     */
    error?: any;
    /**
     * Indicates whether the query is currently loading.
     */
    isLoading?: boolean;
}

/**
 * A function that takes the execution context and returns a value.
 * Used for all dynamic expressions in the query tree (args, collectionExpr, visibilityExpr, data, propsContext values).
 */
declare type ContextFn<R> = (ctx: QueryExecutionContext) => R;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare interface DataOp {
    sourceId: string;
    opId: string;
    userArgs?: Record<string, any>;
    cacheKey?: string;
    invalidatedKeys?: string[] | null;
    roleId?: string | null;
}

/** @deprecated See https://docs.plasmic.app/learn/integrations */
declare interface DataOpConfig {
    name?: string;
    pageIndex?: number;
    pageSize?: number;
}

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare interface DataSourceSchema {
    tables: TableSchema[];
}

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare function deriveFieldConfigs<T extends BaseFieldConfig>(specifiedFieldsPartial: Partial<T>[], schema: TableSchema | undefined, makeDefaultConfig: (field: TableFieldSchema | undefined) => T): {
    mergedFields: T[];
    minimalFullLengthFields: Partial<T>[];
};

declare interface ExecuteOpts {
    userAuthToken?: string;
    user?: PlasmicDataSourceContextValue["user"];
    paginate?: Pagination;
}

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare function executePlasmicDataOp<T extends SingleRowResult | ManyRowsResult>(op: DataOp, opts?: ExecuteOpts): Promise<T>;

/**
 * Executes all queries from a serialized component tree and returns query results.
 *
 * 1. Walk the tree to discover queries, creating StatefulQueryResult + PlasmicQuery
 * 2. Execute all newly discovered queries in parallel
 * 3. After all settle, re-walk. Discover queries from newly expanded repeated nodes
 * Continue until no new queries found.
 */
export declare function executePlasmicQueries(rootNode: QueryComponentNode, env: InitialQueryExecutionContext): Promise<ExecutePlasmicQueriesResult>;

declare interface ExecutePlasmicQueriesResult {
    /** All queries, including nested, by query cache key hash. Passed to PlasmicRootProvider */
    cache: Record<string, unknown>;
    /** Root component query results keyed by query name. */
    queries: Record<string, PlasmicQueryResult>;
}

/** @deprecated no-op function for compatibility only */
export declare function executeServerQuery<F extends (...args: any[]) => any>(_query?: any): Promise<{
    data: ReturnType<F>;
    isLoading: boolean;
}>;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare function Fetcher(props: FetcherProps): React_2.ReactElement | null;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare const FetcherMeta: CodeComponentMeta<FetcherProps>;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare interface FetcherProps extends DataOpConfig {
    dataOp?: DataOp;
    children?: ($queries: Record<string, any>) => React_2.ReactElement | null;
    queries?: Record<string, any>;
}

/**
 * Initial context just before execution.
 * @internal
 */
declare type InitialQueryExecutionContext = Pick<QueryExecutionContext, "$ctx" | "$props">;

export declare function isPlasmicUndefinedDataErrorPromise(x: any): x is PlasmicUndefinedDataErrorPromise;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare function makeCacheKey(dataOp: DataOp, opts?: {
    paginate?: Pagination;
    userAuthToken?: string | null;
}): string;

/**
 * @internal Make a cache key for a query.
 *
 * Wrapped in `.$.` delimiters to match data op cache keys, so invalidation can match
 * the id via `matchesQueryCacheKey` without colliding with other SWR cache keys.
 */
export declare function makeQueryCacheKey(id: string, params: any[]): string;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare interface ManyRowsResult<T = any> {
    data: T[];
    total?: number;
    schema: TableSchema;
    paginate?: Pagination;
}

/**
 * Returns whether `cacheKey` is invalidated by `invalidationKey`. Works for both server
 * query cache keys (built by `makeQueryCacheKey`) and data op cache keys.
 */
export declare function matchesQueryCacheKey(cacheKey: string, invalidationKey: string): boolean;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare function normalizeData(rawData: unknown): NormalizedData | undefined;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare interface NormalizedData {
    data: Record<string, unknown>[];
    schema?: TableSchema;
}

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare interface Pagination {
    pageSize: number;
    pageIndex: number;
}

/** @internal */
export declare interface PlasmicQuery<F extends (...args: any[]) => Promise<unknown> = (...args: any[]) => Promise<unknown>> {
    fn: F;
    args: ContextFn<Parameters<F>>;
    id: string;
}

/** @internal */
export declare interface PlasmicQueryResult<T = unknown> {
    /**
     * Returns the key if params have resolved.
     */
    key: string | null;
    /**
     * Returns the data if the query resolved.
     * Throws the error if the query rejected.
     * Throws PlasmicUndefinedDataErrorPromise if the query params are not ready.
     */
    data: T;
    isLoading: boolean;
}

export declare interface PlasmicUndefinedDataErrorPromise extends Promise<any> {
    plasmicType: "PlasmicUndefinedDataError";
    message: string;
}

/** @internal */
declare interface QueryCodeComponentNode {
    type: "codeComponent";
    propsContext: Record<string, ContextFn<unknown>>;
    subtreePrefetchingConfig?: SerializedSubtreePrefetchingConfig;
    children: QueryNode[];
}

/** @internal */
export declare interface QueryComponentNode {
    type: "component";
    queries: Record<string, PlasmicQuery>;
    propsContext: Record<string, ContextFn<unknown>>;
    /**
     * Lazily initializes $state proxy for this component.
     */
    stateSpecs: $StateSpec[];
    children: QueryNode[];
}

/** @internal */
declare interface QueryDataProviderNode {
    type: "dataProvider";
    name: string;
    data: ContextFn<unknown>;
    children: QueryNode[];
}

/**
 * Context during execution.
 * @internal
 */
export declare type QueryExecutionContext = {
    $ctx: Record<string, unknown>;
    $props: Record<string, unknown>;
    $state: Record<string, unknown>;
    $q: Record<string, PlasmicQueryResult>;
};

/** @internal */
declare type QueryNode = QueryComponentNode | QueryCodeComponentNode | QueryRepeatedNode | QueryDataProviderNode | QueryVisibilityNode;

/** @internal */
declare interface QueryRepeatedNode {
    type: "repeated";
    collectionExpr: ContextFn<unknown>;
    itemName: string;
    indexName: string;
    children: QueryNode[];
}

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare type QueryResult = Partial<ManyRowsResult<any>> & {
    error?: any;
    isLoading?: boolean;
};

/** @internal */
declare interface QueryVisibilityNode {
    type: "visibility";
    visibilityExpr: ContextFn<unknown>;
    children: QueryNode[];
}

declare type ResolvableDataOp = DataOp | undefined | null | (() => DataOp | undefined | null);

/** Execute a function, returning a result-like type. */
export declare function _safeExecResult<T>(tryData: () => T): {
    data: T;
} | {
    promise: PlasmicUndefinedDataErrorPromise;
} | {
    error: unknown;
};

declare type SerializedSubtreePrefetchingConfig = boolean;

/**
 * Wraps a Promise so that it can be easily resolved/rejected
 * outside the executor param of the Promise constructor.
 */
declare class SettablePromise<T> {
    readonly promise: Promise<T>;
    private _resolve;
    private _reject;
    constructor();
    resolve(value: T): void;
    reject(error: unknown): void;
}

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare interface SingleRowResult<T = any> {
    data: T;
    schema: TableSchema;
}

/** @internal */
export declare class _StatefulQueryResult<T = unknown> implements PlasmicQueryResult<T> {
    current: _StatefulQueryState<T>;
    settable: SettablePromise<T>;
    private readonly listeners;
    constructor();
    private transitionState;
    addListener(listener: _StateListener<T>): void;
    removeListener(listener: _StateListener<T>): void;
    private notifyListeners;
    reset(): void;
    loadingPromise(key: string, promise: Promise<T>): void;
    resolvePromise(key: string, data: T): void;
    /**
     * Reject is allowed if:
     * 1) no key / state is initial, which means params resolution failed
     * 2) key / state is loading, which means we need to check the keys match
     */
    rejectPromise(key: string | null, error: unknown): void;
    toJSON(): _StatefulQueryState<T>;
    get key(): string | null;
    get data(): T;
    get isLoading(): boolean;
    getDoneResult(): Promise<PlasmicQueryResult<T> & {
        current: {
            state: "done";
        };
    }>;
}

/** @internal */
export declare type _StatefulQueryState<T = unknown> = {
    state: "initial";
    key: null;
} | {
    state: "loading";
    key: string;
} | {
    state: "done";
    key: string;
    data: T;
} | {
    state: "done";
    key: string | null;
    error: unknown;
};

/** @internal */
export declare type _StateListener<T = unknown> = (state: _StatefulQueryState<T>, prevState: _StatefulQueryState<T>) => void;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare interface TableFieldSchema {
    id: string;
    label?: string;
    type: TableFieldType;
    readOnly: boolean;
    primaryKey?: boolean;
    options?: string[];
}

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare type TableFieldType = "string" | "boolean" | "number" | "date" | "datetime" | "enum" | "json" | "unknown";

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare interface TableSchema {
    id: string;
    schema?: string;
    label?: string;
    fields: TableFieldSchema[];
}

export declare function throwIfPlasmicUndefinedDataError(err: unknown): void;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare function useNormalizedData(rawData: unknown): NormalizedData | undefined;

export { usePlasmicDataConfig }

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare function usePlasmicDataMutationOp<T extends SingleRowResult | ManyRowsResult>(dataOp: ResolvableDataOp): () => Promise<T | undefined>;

/** @deprecated See https://docs.plasmic.app/learn/integrations */
export declare function usePlasmicDataOp<T extends SingleRowResult | ManyRowsResult, E = any>(dataOp: ResolvableDataOp, opts?: {
    paginate?: Pagination;
    noUndefinedDataProxy?: boolean;
}): ClientQueryResult<T["data"]>;

/**
 * Returns a function that invalidates cached query data. Accepts a list of invalidation keys
 * or `plasmic_refresh_all` to invalidate everything.
 */
export declare function usePlasmicInvalidate(): (invalidatedKeys: string[] | null | undefined) => Promise<any[] | undefined>;

/**
 * @internal
 * This hook's job is to execute queries and re-render when query state changes.
 * Data caching can be controlled via @plasmicapp/query.
 *
 * The actual results will be available in the returned $queries object.
 *
 * Prefetched query data can be passed to
 * <PlasmicQueryDataProvider prefetchedCache={...}>.
 *
 * Example codegen:
 *
 * export const queryTree = {
 *   type: "component",
 *   queries: {
 *     films: { fn: $$.fetch, id: "fetch", args: ({ $q, $props, $ctx }) => [...] }
 *   },
 *   propsContext: {},
 * };
 *
 * export function ClientComponent($props, $ctx) {
 *   const $q = usePlasmicQueries(queryTree, { $ctx, $props, $state: null });
 *   return <div>{$q.films.data}</div>
 * }
 */
export declare function usePlasmicQueries(tree: QueryComponentNode, env: ClientQueryExecutionContext): Record<string, PlasmicQueryResult>;

/**
 * @internal
 * Wraps each PlasmicQueryResult so that they return a hardcoded string for
 * undefined/loading and error cases.
 */
export declare function wrapPlasmicQueriesForMetadata<T extends Record<string, PlasmicQueryResult>>(queries: T, ifUndefined?: (promise: PlasmicUndefinedDataErrorPromise) => unknown, ifError?: (err: unknown) => unknown): T;

export { }