import * as Schema from 'effect/Schema';
import { EID, URI } from '@dxos/keys';
/**
 * Filter by object type and properties.
 *
 * Clauses are combined using logical AND.
 */
declare const FilterObject_: Schema.Struct<{
    type: Schema.Literal<["object"]>;
    typename: Schema.Union<[Schema.Schema<URI.URI, URI.URI, never>, typeof Schema.Null]>;
    id: Schema.optional<Schema.Array$<import("@dxos/keys").EntityIdClass>>;
    /**
     * Filter by property.
     * Must not include object ID.
     */
    props: Schema.Record$<Schema.SchemaClass<string, string, never>, Schema.suspend<FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, never>>;
    /**
     * Objects that have any of the given foreign keys.
     */
    foreignKeys: Schema.optional<Schema.Array$<Schema.Schema<{
        readonly source: string;
        readonly id: string;
    }, {
        readonly source: string;
        readonly id: string;
    }, never>>>;
    /**
     * Match objects whose meta `key` equals this fully-qualified registry key (FQN format).
     */
    metaKey: Schema.optional<typeof Schema.String>;
    /**
     * Semver range matched against the object's meta `version`.
     * Only consulted when {@link metaKey} is set. Objects with no `version` do not satisfy a version-constrained filter.
     */
    metaVersion: Schema.optional<typeof Schema.String>;
}>;
export interface FilterObject extends Schema.Schema.Type<typeof FilterObject_> {
}
export declare const FilterObject: Schema.Schema<FilterObject>;
/**
 * Compare.
 */
declare const FilterCompare_: Schema.Struct<{
    type: Schema.Literal<["compare"]>;
    operator: Schema.Literal<["eq", "neq", "gt", "gte", "lt", "lte"]>;
    value: typeof Schema.Unknown;
}>;
export interface FilterCompare extends Schema.Schema.Type<typeof FilterCompare_> {
}
export declare const FilterCompare: Schema.Schema<FilterCompare>;
/**
 * In.
 */
declare const FilterIn_: Schema.Struct<{
    type: Schema.Literal<["in"]>;
    values: Schema.Array$<typeof Schema.Any>;
}>;
export interface FilterIn extends Schema.Schema.Type<typeof FilterIn_> {
}
export declare const FilterIn: Schema.Schema<FilterIn>;
/**
 * Contains.
 */
declare const FilterContains_: Schema.Struct<{
    type: Schema.Literal<["contains"]>;
    value: typeof Schema.Any;
}>;
export interface FilterContains extends Schema.Schema.Type<typeof FilterContains_> {
}
/**
 * Predicate for an array property to contain the provided value.
 * Nested objects are matched using strict structural matching.
 */
export declare const FilterContains: Schema.Schema<FilterContains>;
/**
 * Filters objects that have certain tag.
 */
declare const FilterTag_: Schema.Struct<{
    type: Schema.Literal<["tag"]>;
    tag: typeof Schema.String;
}>;
export interface FilterTag extends Schema.Schema.Type<typeof FilterTag_> {
}
export declare const FilterTag: Schema.Schema<FilterTag>;
/**
 * Range.
 */
declare const FilterRange_: Schema.Struct<{
    type: Schema.Literal<["range"]>;
    from: typeof Schema.Any;
    to: typeof Schema.Any;
}>;
export interface FilterRange extends Schema.Schema.Type<typeof FilterRange_> {
}
export declare const FilterRange: Schema.Schema<FilterRange>;
/**
 * Filter by system timestamp (createdAt / updatedAt).
 * Timestamps are unix milliseconds stored in the object meta index.
 */
declare const FilterTimestamp_: Schema.Struct<{
    type: Schema.Literal<["timestamp"]>;
    field: Schema.Literal<["createdAt", "updatedAt"]>;
    operator: Schema.Literal<["gt", "gte", "lt", "lte"]>;
    value: typeof Schema.Number;
}>;
export interface FilterTimestamp extends Schema.Schema.Type<typeof FilterTimestamp_> {
}
export declare const FilterTimestamp: Schema.Schema<FilterTimestamp>;
/**
 * Text search.
 */
declare const FilterTextSearch_: Schema.Struct<{
    type: Schema.Literal<["text-search"]>;
    text: typeof Schema.String;
    searchKind: Schema.optional<Schema.Literal<["full-text", "vector"]>>;
}>;
export interface FilterTextSearch extends Schema.Schema.Type<typeof FilterTextSearch_> {
}
export declare const FilterTextSearch: Schema.Schema<FilterTextSearch>;
/**
 * Not.
 */
declare const FilterNot_: Schema.Struct<{
    type: Schema.Literal<["not"]>;
    filter: Schema.suspend<FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, never>;
}>;
export interface FilterNot extends Schema.Schema.Type<typeof FilterNot_> {
}
export declare const FilterNot: Schema.Schema<FilterNot>;
/**
 * And.
 */
declare const FilterAnd_: Schema.Struct<{
    type: Schema.Literal<["and"]>;
    filters: Schema.Array$<Schema.suspend<FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, never>>;
}>;
export interface FilterAnd extends Schema.Schema.Type<typeof FilterAnd_> {
}
export declare const FilterAnd: Schema.Schema<FilterAnd>;
/**
 * Or.
 */
declare const FilterOr_: Schema.Struct<{
    type: Schema.Literal<["or"]>;
    filters: Schema.Array$<Schema.suspend<FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, never>>;
}>;
export interface FilterOr extends Schema.Schema.Type<typeof FilterOr_> {
}
export declare const FilterOr: Schema.Schema<FilterOr>;
/**
 * Filter objects that are children of the specified parents.
 * With transitive=true (default), matches grandchildren and beyond.
 */
declare const FilterChildOf_: Schema.Struct<{
    type: Schema.Literal<["child-of"]>;
    /** Parent DXNs to match children of. */
    parents: Schema.Array$<Schema.Schema<EID.EID, EID.EID, never>>;
    /** Whether to match transitively (grandchildren, etc.). Defaults to true. */
    transitive: typeof Schema.Boolean;
}>;
export interface FilterChildOf extends Schema.Schema.Type<typeof FilterChildOf_> {
}
export declare const FilterChildOf: Schema.Schema<FilterChildOf>;
/**
 * Union of filters.
 */
export declare const Filter: Schema.Union<[Schema.Schema<FilterObject, FilterObject, never>, Schema.Schema<FilterCompare, FilterCompare, never>, Schema.Schema<FilterIn, FilterIn, never>, Schema.Schema<FilterContains, FilterContains, never>, Schema.Schema<FilterTag, FilterTag, never>, Schema.Schema<FilterRange, FilterRange, never>, Schema.Schema<FilterTimestamp, FilterTimestamp, never>, Schema.Schema<FilterTextSearch, FilterTextSearch, never>, Schema.Schema<FilterChildOf, FilterChildOf, never>, Schema.Schema<FilterNot, FilterNot, never>, Schema.Schema<FilterAnd, FilterAnd, never>, Schema.Schema<FilterOr, FilterOr, never>]>;
export type Filter = Schema.Schema.Type<typeof Filter>;
/**
 * Query objects by type, id, and/or predicates.
 */
declare const QuerySelectClause_: Schema.Struct<{
    type: Schema.Literal<["select"]>;
    filter: Schema.suspend<FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, never>;
}>;
export interface QuerySelectClause extends Schema.Schema.Type<typeof QuerySelectClause_> {
}
export declare const QuerySelectClause: Schema.Schema<QuerySelectClause>;
/**
 * Filter objects from selection.
 */
declare const QueryFilterClause_: Schema.Struct<{
    type: Schema.Literal<["filter"]>;
    selection: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    filter: Schema.suspend<FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, never>;
}>;
export interface QueryFilterClause extends Schema.Schema.Type<typeof QueryFilterClause_> {
}
export declare const QueryFilterClause: Schema.Schema<QueryFilterClause>;
/**
 * Traverse references from an anchor object.
 */
declare const QueryReferenceTraversalClause_: Schema.Struct<{
    type: Schema.Literal<["reference-traversal"]>;
    anchor: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    property: typeof Schema.String;
}>;
export interface QueryReferenceTraversalClause extends Schema.Schema.Type<typeof QueryReferenceTraversalClause_> {
}
export declare const QueryReferenceTraversalClause: Schema.Schema<QueryReferenceTraversalClause>;
/**
 * Traverse incoming references to an anchor object.
 */
declare const QueryIncomingReferencesClause_: Schema.Struct<{
    type: Schema.Literal<["incoming-references"]>;
    anchor: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    /**
     * Property path where the reference is located.
     * If null, matches references from any property.
     */
    property: Schema.NullOr<typeof Schema.String>;
    typename: Schema.Union<[Schema.Schema<URI.URI, URI.URI, never>, typeof Schema.Null]>;
}>;
export interface QueryIncomingReferencesClause extends Schema.Schema.Type<typeof QueryIncomingReferencesClause_> {
}
export declare const QueryIncomingReferencesClause: Schema.Schema<QueryIncomingReferencesClause>;
/**
 * Traverse relations connecting to an anchor object.
 */
declare const QueryRelationClause_: Schema.Struct<{
    type: Schema.Literal<["relation"]>;
    anchor: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    /**
     * outgoing: anchor is the source of the relation.
     * incoming: anchor is the target of the relation.
     * both: anchor is either the source or target of the relation.
     */
    direction: Schema.Literal<["outgoing", "incoming", "both"]>;
    filter: Schema.optional<Schema.suspend<FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, FilterAnd | FilterChildOf | FilterCompare | FilterContains | FilterIn | FilterNot | FilterObject | FilterOr | FilterRange | FilterTag | FilterTextSearch | FilterTimestamp, never>>;
}>;
export interface QueryRelationClause extends Schema.Schema.Type<typeof QueryRelationClause_> {
}
export declare const QueryRelationClause: Schema.Schema<QueryRelationClause>;
/**
 * Traverse into the source or target of a relation.
 */
declare const QueryRelationTraversalClause_: Schema.Struct<{
    type: Schema.Literal<["relation-traversal"]>;
    anchor: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    direction: Schema.Literal<["source", "target", "both"]>;
}>;
export interface QueryRelationTraversalClause extends Schema.Schema.Type<typeof QueryRelationTraversalClause_> {
}
export declare const QueryRelationTraversalClause: Schema.Schema<QueryRelationTraversalClause>;
/**
 * Traverse parent-child hierarchy.
 */
declare const QueryHierarchyTraversalClause_: Schema.Struct<{
    type: Schema.Literal<["hierarchy-traversal"]>;
    anchor: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    /**
     * to-parent: traverse from child to parent.
     * to-children: traverse from parent to children.
     */
    direction: Schema.Literal<["to-parent", "to-children"]>;
}>;
export interface QueryHierarchyTraversalClause extends Schema.Schema.Type<typeof QueryHierarchyTraversalClause_> {
}
export declare const QueryHierarchyTraversalClause: Schema.Schema<QueryHierarchyTraversalClause>;
/**
 * Union of multiple queries.
 */
declare const QueryUnionClause_: Schema.Struct<{
    type: Schema.Literal<["union"]>;
    queries: Schema.Array$<Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>>;
}>;
export interface QueryUnionClause extends Schema.Schema.Type<typeof QueryUnionClause_> {
}
export declare const QueryUnionClause: Schema.Schema<QueryUnionClause>;
/**
 * Set difference of two queries.
 */
declare const QuerySetDifferenceClause_: Schema.Struct<{
    type: Schema.Literal<["set-difference"]>;
    source: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    exclude: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
}>;
export interface QuerySetDifferenceClause extends Schema.Schema.Type<typeof QuerySetDifferenceClause_> {
}
export declare const QuerySetDifferenceClause: Schema.Schema<QuerySetDifferenceClause>;
export declare const OrderDirection: Schema.Literal<["asc", "desc"]>;
export type OrderDirection = Schema.Schema.Type<typeof OrderDirection>;
declare const Order_: Schema.Union<[Schema.Struct<{
    kind: Schema.Literal<["natural"]>;
}>, Schema.Struct<{
    kind: Schema.Literal<["property"]>;
    property: typeof Schema.String;
    direction: Schema.Literal<["asc", "desc"]>;
}>, Schema.Struct<{
    kind: Schema.Literal<["rank"]>;
    direction: Schema.Literal<["asc", "desc"]>;
}>, Schema.Struct<{
    kind: Schema.Literal<["timestamp"]>;
    field: Schema.Literal<["createdAt", "updatedAt"]>;
    direction: Schema.Literal<["asc", "desc"]>;
}>]>;
export type Order = Schema.Schema.Type<typeof Order_>;
export declare const Order: Schema.Schema<Order>;
/**
 * Order the query results.
 * Left-to-right the orders dominate.
 */
declare const QueryOrderClause_: Schema.Struct<{
    type: Schema.Literal<["order"]>;
    query: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    order: Schema.Array$<Schema.Schema<{
        readonly kind: "natural";
    } | {
        readonly kind: "property";
        readonly property: string;
        readonly direction: "asc" | "desc";
    } | {
        readonly kind: "rank";
        readonly direction: "asc" | "desc";
    } | {
        readonly kind: "timestamp";
        readonly field: "createdAt" | "updatedAt";
        readonly direction: "asc" | "desc";
    }, {
        readonly kind: "natural";
    } | {
        readonly kind: "property";
        readonly property: string;
        readonly direction: "asc" | "desc";
    } | {
        readonly kind: "rank";
        readonly direction: "asc" | "desc";
    } | {
        readonly kind: "timestamp";
        readonly field: "createdAt" | "updatedAt";
        readonly direction: "asc" | "desc";
    }, never>>;
}>;
export interface QueryOrderClause extends Schema.Schema.Type<typeof QueryOrderClause_> {
}
export declare const QueryOrderClause: Schema.Schema<QueryOrderClause>;
/**
 * Add options to a query.
 */
declare const QueryOptionsClause_: Schema.Struct<{
    type: Schema.Literal<["options"]>;
    query: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    options: Schema.suspend<{
        readonly deleted?: "exclude" | "include" | "only" | undefined;
        readonly debugLabel?: string | undefined;
    }, {
        readonly debugLabel?: string | undefined;
        readonly deleted?: "exclude" | "include" | "only" | undefined;
    }, never>;
}>;
export interface QueryOptionsClause extends Schema.Schema.Type<typeof QueryOptionsClause_> {
}
export declare const QueryOptionsClause: Schema.Schema<QueryOptionsClause>;
/**
 * Limit the number of results.
 */
declare const QueryLimitClause_: Schema.Struct<{
    type: Schema.Literal<["limit"]>;
    query: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    limit: typeof Schema.Number;
}>;
export interface QueryLimitClause extends Schema.Schema.Type<typeof QueryLimitClause_> {
}
export declare const QueryLimitClause: Schema.Schema<QueryLimitClause>;
export declare const QueryFromClause_: Schema.Struct<{
    type: Schema.Literal<["from"]>;
    query: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    from: Schema.Union<[Schema.TaggedStruct<"scope", {
        scopes: Schema.Array$<Schema.suspend<{
            readonly _tag: "space";
            readonly spaceId?: string | undefined;
            readonly includeAllFeeds?: boolean | undefined;
        } | {
            readonly _tag: "feed";
            readonly feedUri: string;
        } | {
            readonly _tag: "registry";
            readonly location: "local" | "remote";
        }, {
            readonly _tag: "space";
            readonly includeAllFeeds?: boolean | undefined;
            readonly spaceId?: string | undefined;
        } | {
            readonly _tag: "feed";
            readonly feedUri: string;
        } | {
            readonly _tag: "registry";
            readonly location: "local" | "remote";
        }, never>>;
    }>, Schema.TaggedStruct<"query", {
        query: Schema.suspend<QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, QueryFilterClause | QueryFromClause | QueryHierarchyTraversalClause | QueryIncomingReferencesClause | QueryLimitClause | QueryOptionsClause | QueryOrderClause | QueryReferenceTraversalClause | QueryRelationClause | QueryRelationTraversalClause | QuerySelectClause | QuerySetDifferenceClause | QueryUnionClause, never>;
    }>]>;
}>;
export interface QueryFromClause extends Schema.Schema.Type<typeof QueryFromClause_> {
}
export declare const QueryFromClause: Schema.Schema<QueryFromClause>;
declare const Query_: Schema.Union<[Schema.Schema<QuerySelectClause, QuerySelectClause, never>, Schema.Schema<QueryFilterClause, QueryFilterClause, never>, Schema.Schema<QueryReferenceTraversalClause, QueryReferenceTraversalClause, never>, Schema.Schema<QueryIncomingReferencesClause, QueryIncomingReferencesClause, never>, Schema.Schema<QueryRelationClause, QueryRelationClause, never>, Schema.Schema<QueryRelationTraversalClause, QueryRelationTraversalClause, never>, Schema.Schema<QueryHierarchyTraversalClause, QueryHierarchyTraversalClause, never>, Schema.Schema<QueryUnionClause, QueryUnionClause, never>, Schema.Schema<QuerySetDifferenceClause, QuerySetDifferenceClause, never>, Schema.Schema<QueryOrderClause, QueryOrderClause, never>, Schema.Schema<QueryOptionsClause, QueryOptionsClause, never>, Schema.Schema<QueryLimitClause, QueryLimitClause, never>, Schema.Schema<QueryFromClause, QueryFromClause, never>]>;
export type Query = Schema.Schema.Type<typeof Query_>;
export declare const Query: Schema.Schema<Query>;
export declare const QueryOptions: Schema.Struct<{
    /**
     * Nested select statements will use this option to filter deleted objects.
     */
    deleted: Schema.optional<Schema.Literal<["include", "exclude", "only"]>>;
    /**
     * Diagnostics-only label for logs / tooling (not used by execution semantics).
     */
    debugLabel: Schema.optional<typeof Schema.String>;
}>;
export interface QueryOptions extends Schema.Schema.Type<typeof QueryOptions> {
}
/**
 * Selects from a space (automerge documents).
 * When `spaceId` is omitted, targets the owning space — i.e. the space of whichever
 * database executes the query. This lets callers reference "this space" without
 * having to look up its id.
 * When `includeAllFeeds` is true, also selects from all feeds belonging to that space.
 */
export declare const SpaceScope: Schema.TaggedStruct<"space", {
    spaceId: Schema.optional<typeof Schema.String>;
    includeAllFeeds: Schema.optional<typeof Schema.Boolean>;
}>;
export interface SpaceScope extends Schema.Schema.Type<typeof SpaceScope> {
}
/**
 * Selects from a specific feed (by its underlying queue DXN).
 */
export declare const FeedScope: Schema.TaggedStruct<"feed", {
    feedUri: typeof Schema.String;
}>;
export interface FeedScope extends Schema.Schema.Type<typeof FeedScope> {
}
/**
 * Selects from a code-shipped object registry.
 *
 * - `'local'`  — the in-process registry attached to the hypergraph.
 * - `'remote'` — a future remote registry service (not yet implemented).
 *
 * To include both, add two separate `RegistryScope` entries to the `scopes` array.
 */
export declare const RegistryScope: Schema.TaggedStruct<"registry", {
    location: Schema.Literal<["local", "remote"]>;
}>;
export interface RegistryScope extends Schema.Schema.Type<typeof RegistryScope> {
}
/**
 * Specifies the scope of the data to query from.
 * A `from` clause may carry multiple scopes; results are unioned across them.
 */
export declare const Scope: Schema.Union<[Schema.TaggedStruct<"space", {
    spaceId: Schema.optional<typeof Schema.String>;
    includeAllFeeds: Schema.optional<typeof Schema.Boolean>;
}>, Schema.TaggedStruct<"feed", {
    feedUri: typeof Schema.String;
}>, Schema.TaggedStruct<"registry", {
    location: Schema.Literal<["local", "remote"]>;
}>]>;
export type Scope = Schema.Schema.Type<typeof Scope>;
export declare const visit: (query: Query, visitor: (node: Query) => void) => void;
/**
 * Recursively transforms a query tree bottom-up.
 * The mapper receives each node with its children already transformed.
 */
export declare const map: (query: Query, mapper: (node: Query) => Query) => Query;
export declare const fold: <T>(query: Query, reducer: (node: Query) => T) => T[];
export {};
//# sourceMappingURL=ast.d.ts.map