import { process } from 'gremlin';
import { ANY_PROPERTY, Id, ID, LABEL, MergePropertiesDefinitions, NonOptionalProperty, NonOptionalPropertyDefinition, OptionalPropertyDefinition, PrimitiveType, Properties, PropertiesDefinition, PropertiesForOutput, PropertyDefinition } from './PropertiesDefinition';
import Step, { ExtractStepValue, GetStepFunc } from './Step';
import type { IfTrue } from './utilityTypes';
import { AddMappedValueType, ArrayValueTypes } from './utilityTypes';
import ProjectStep from './ProjectStep';
import MapStep from './MapStep';
import { PropertyValueStep } from './PropertyValueStep';
declare type GraphTraversal = process.GraphTraversal;
export declare const NO_PROPERTY: unique symbol;
export declare type AnyProperties<T, D extends PropertiesDefinition, AdditionalTypes = never> = D[typeof ANY_PROPERTY] extends NonOptionalPropertyDefinition ? T & Record<Exclude<keyof T, typeof ID | typeof LABEL | keyof D>, NonOptionalProperty<D[typeof ANY_PROPERTY]> | typeof NO_PROPERTY | AdditionalTypes> : Record<Exclude<keyof T, typeof ID | typeof LABEL | keyof D>, never>;
export declare type Find<T, D extends PropertiesDefinition> = Partial<AddMappedValueType<Omit<Properties<D, typeof NO_PROPERTY>, typeof ANY_PROPERTY>, process.P>> & AnyProperties<T, D, process.P> & {
    [ID]?: Id | process.P;
    [LABEL]?: never;
};
declare type ValueObjKey<D extends PropertiesDefinition, IncludeId extends boolean, IncludeLabel extends boolean> = Extract<keyof D, string> | IfTrue<IncludeId, typeof ID> | IfTrue<IncludeLabel, typeof LABEL> | (D[typeof ANY_PROPERTY] extends NonOptionalPropertyDefinition ? string : never);
declare type ValueObjPropertiesDefinition<D extends PropertiesDefinition, IncludeId extends boolean, IncludeLabel extends boolean, ValueObjKeys extends ValueObjKey<D, IncludeId, IncludeLabel>[]> = ValueObjKeys extends [] | (typeof ID | typeof LABEL)[] ? D : {
    [K in Extract<ArrayValueTypes<ValueObjKeys>, string>]: K extends keyof D ? D[K] : D[typeof ANY_PROPERTY] extends NonOptionalPropertyDefinition ? OptionalPropertyDefinition<D[typeof ANY_PROPERTY]> : never;
};
declare type NonAnyPropertyValueAccessor<D extends PropertiesDefinition> = {
    readonly [K in keyof D]: () => PropertyValueStep<D[K]>;
};
declare type PropertyValueAccessor<D extends PropertiesDefinition> = D[typeof ANY_PROPERTY] extends NonOptionalPropertyDefinition ? NonAnyPropertyValueAccessor<Omit<D, typeof ANY_PROPERTY>> & Record<string, () => PropertyValueStep<D[typeof ANY_PROPERTY]>> : NonAnyPropertyValueAccessor<D>;
export declare class ObjectStep<D extends PropertiesDefinition, IncludeId extends boolean, IncludeLabel extends boolean> extends Step<PropertiesForOutput<D, IncludeId, IncludeLabel>> {
    readonly properties: D;
    readonly includeId: IncludeId;
    readonly includeLabel: IncludeLabel;
    readonly value: PropertyValueAccessor<D>;
    constructor(q: GraphTraversal, properties: D, includeId: IncludeId, includeLabel: IncludeLabel);
    valueObj<Keys extends ValueObjKey<D, IncludeId, IncludeLabel>[]>(...propertyKeys: Keys): ObjectStep<ValueObjPropertiesDefinition<D, IncludeId, IncludeLabel, Keys>, typeof ID extends ArrayValueTypes<Keys> ? true : false, typeof LABEL extends ArrayValueTypes<Keys> ? true : false>;
    find<T>(filter?: Find<T, D>): this;
    protected createPropertyValueStep<P extends PropertyDefinition>(propertyDefinition: P, requestedProperty: string): PropertyValueStep<P>;
    protected queryFindDoesNotHaveProperty(key: string): void;
    protected queryFindHasPropertyValue(key: string | typeof ID, value: PrimitiveType | process.P): void;
    protected queryValueObj(keys: string[], includeId: boolean, includeLabel: boolean): void;
    project<M>(map: {
        [K in keyof M]: GetStepFunc<this, M[K]>;
    }): ProjectStep<M>;
    groupByMap<KeyStep extends Step<KeyType>, ValueStep extends Step<ValueType>, KeyType = ExtractStepValue<KeyStep>, ValueType = ExtractStepValue<ValueStep>>(key: (_: this) => KeyStep, value: (_: this) => ValueStep): MapStep<KeyStep, ValueStep, Map<KeyType, ValueType>, (v: unknown, keyStep: KeyStep, valueStep: ValueStep) => Map<KeyType, ValueType>, KeyType, ValueType>;
    groupBy<KeyType extends PrimitiveType, KeyStep extends Step<KeyType>, ValueStep extends Step<ValueType>, ValueType = ExtractStepValue<ValueStep>>(key: (_: this) => KeyStep, value: (_: this) => ValueStep): MapStep<KeyStep, ValueStep, {
        [k: string]: ValueType;
    }, (v: unknown, keyStep: KeyStep, valueStep: ValueStep) => {
        [k: string]: ValueType;
    }, KeyType, ValueType>;
    merge<A_D extends PropertiesDefinition, A_IncludeId extends boolean, A_IncludeLabel extends boolean, B_D extends PropertiesDefinition, B_IncludeId extends boolean, B_IncludeLabel extends boolean>(getA: (_: this) => ObjectStep<A_D, A_IncludeId, A_IncludeLabel>, getB: (_: this) => ObjectStep<B_D, B_IncludeId, B_IncludeLabel>): ObjectStep<MergePropertiesDefinitions<A_D, B_D>, IfTrue<A_IncludeId, true> | IfTrue<B_IncludeId, true>, IfTrue<A_IncludeLabel, true> | IfTrue<B_IncludeLabel, true>>;
    deserialize(v: unknown): PropertiesForOutput<D, IncludeId, IncludeLabel>;
    createContinuation<This extends this>(g: GraphTraversal): this;
    private assertIsObjectStep;
}
export {};