import { process } from 'gremlin';
import { NonEmpty } from './NonEmpty';
import Step, { ExtractStepValue } from './Step';
import ProjectStep from './ProjectStep';
import IdStep from './IdStep';
import LabelStep from './LabelStep';
import GroupByStep from './GroupByStep';
declare type GraphTraversal = process.GraphTraversal;
export declare const ANY_PROPERTY: unique symbol;
export declare const NO_PROPERTY: unique symbol;
export declare const NO_PROPERTIES: {
    readonly [K: string]: never;
};
declare type PrimitivePropertyDefinitionCombo<A extends string, B extends string> = `${A} | ${B}` | `${B} | ${A}`;
declare type PrimitivePropertyDefinition = 'boolean' | 'string' | 'number' | PrimitivePropertyDefinitionCombo<'boolean', 'number'> | PrimitivePropertyDefinitionCombo<'boolean', 'string'> | PrimitivePropertyDefinitionCombo<'string', 'number'> | PrimitivePropertyDefinitionCombo<'string', PrimitivePropertyDefinitionCombo<'boolean', 'number'>> | PrimitivePropertyDefinitionCombo<'number', PrimitivePropertyDefinitionCombo<'boolean', 'string'>> | PrimitivePropertyDefinitionCombo<'boolean', PrimitivePropertyDefinitionCombo<'string', 'number'>>;
declare type EnumPropertyDefinition = Record<string, string>;
export declare type NonOptionalPropertyDefinition = PrimitivePropertyDefinition | EnumPropertyDefinition;
export declare type PropertyDefinition = NonOptionalPropertyDefinition | OptionalPropertyDefinition<NonOptionalPropertyDefinition>;
export declare type Definition = {
    readonly [K: string]: PropertyDefinition;
    readonly [ANY_PROPERTY]?: NonOptionalPropertyDefinition;
};
declare type PrimitivePropertySingle<P> = P extends 'boolean' ? boolean : P extends 'string' ? string : P extends 'number' ? number : never;
declare type AllPropertyTypes = PrimitivePropertySingle<any>;
declare type PrimitiveProperty<S> = S extends `${infer T} | ${infer U}` ? PrimitivePropertySingle<T> | PrimitiveProperty<U> : PrimitivePropertySingle<S>;
declare type NonOptionalProperty<P extends NonOptionalPropertyDefinition> = P extends EnumPropertyDefinition ? P[keyof P] : PrimitiveProperty<P>;
export declare type Property<P extends PropertyDefinition, OptionalType> = P extends NonOptionalPropertyDefinition ? NonOptionalProperty<P> : P extends OptionalPropertyDefinition<infer X> ? X extends NonOptionalPropertyDefinition ? NonOptionalProperty<X> | OptionalType : never : never;
declare type Properties<D extends Definition, AdditionalAllowedValues = never, OptionalType = typeof NO_PROPERTY> = {
    [K in Extract<keyof D, string>]: Property<D[K], OptionalType> | AdditionalAllowedValues;
};
declare type AnyProperties<T, D extends Definition, AdditionalTypes = typeof NO_PROPERTY> = D[typeof ANY_PROPERTY] extends NonOptionalPropertyDefinition ? T & Record<Exclude<keyof T, keyof D>, NonOptionalProperty<D[typeof ANY_PROPERTY]> | AdditionalTypes> : Record<Exclude<keyof T, keyof D>, never>;
export declare type Output<D extends Definition> = Properties<D, never, undefined> & AnyProperties<Record<string, AllPropertyTypes>, D, never>;
export declare type Find<T, D extends Definition> = Partial<Properties<D, process.P>> & AnyProperties<T, D, typeof NO_PROPERTY | process.P>;
export declare type Update<T, D extends Definition> = Partial<Properties<D>> & AnyProperties<T, D>;
export declare type Insert<T, D extends Definition> = Properties<D> & AnyProperties<T, D>;
declare type Value<D extends Definition> = {
    readonly [K in Extract<keyof D, string>]: () => PropertyValue<D, K>;
} & {
    readonly [K: string]: D[typeof ANY_PROPERTY] extends NonOptionalPropertyDefinition ? () => PropertyValue<D, typeof ANY_PROPERTY> : never;
};
export declare type Id = string | number;
export declare abstract class Queryable<D extends Definition> extends Step<Output<D>> {
    readonly properties: D;
    readonly value: Value<D>;
    protected constructor(q: GraphTraversal, properties: D, _ts?: D);
    fetchOne(): Promise<Output<D>>;
    fetchAll(): Promise<Output<D>[]>;
    project<M>(map: {
        [K in keyof M]: (_: this) => Step<M[K]>;
    }): ProjectStep<M>;
    groupBy<KeyStep extends Step<KeyType>, ValueStep extends Step<ValueType>, KeyType = ExtractStepValue<KeyStep>, ValueType = ExtractStepValue<ValueStep>>(key: (_: this) => KeyStep, value: (_: this) => ValueStep): GroupByStep<KeyStep, ValueStep, KeyType, ValueType>;
    id(): IdStep;
    label(): LabelStep;
    byId(ids: NonEmpty<Id>): this;
    find<T>(filter?: Find<T, D>): this;
    update<T>(properties: Update<T, D>): this;
    deserialize(v: unknown): Output<D>;
    protected setProperties(properties: Record<string, AllPropertyTypes | typeof NO_PROPERTY>, dropOnNoProperty: boolean): this;
    protected abstract setProperty<K extends keyof D>(property: K, value: unknown): void;
    private deserializeAndAddAnyProperties;
    private fetch;
}
export declare class OptionalPropertyDefinition<T extends NonOptionalPropertyDefinition> {
    readonly type: T;
    constructor(type: T);
}
export declare const optional: <T extends NonOptionalPropertyDefinition>(type: T) => OptionalPropertyDefinition<T>;
export declare class PropertyValue<D extends Definition, K extends keyof D> extends Step<Property<D[K], never>> {
    private readonly queryableName;
    private readonly propertiesDefinition;
    private readonly definitionProperty;
    private requestedProperty;
    constructor(g: GraphTraversal, queryableName: string, propertiesDefinition: D, definitionProperty: K, requestedProperty: string);
    deserialize(raw: unknown): Property<D[K], never>;
}
export {};