interface ViewReference {
    type: "view";
    space: string;
    externalId: string;
    version: string;
}
interface ViewPropertyType {
    type?: string;
    source?: ViewReference;
    list?: boolean;
    values?: Record<string, {
        name?: string;
    }>;
}
interface ViewPropertyDefinition {
    container: unknown;
    containerPropertyIdentifier: string;
    type: ViewPropertyType;
    nullable?: boolean;
}
interface ReverseDirectRelationConnection {
    through: {
        source: ViewReference;
        identifier: string;
    };
    source: ViewReference;
    connectionType?: string;
    targetsList?: boolean;
}
interface EdgeConnection {
    type: unknown;
    source: ViewReference;
    direction?: "outwards" | "inwards";
}
type ViewDefinitionProperty = ViewPropertyDefinition | ReverseDirectRelationConnection | EdgeConnection;
interface ViewDefinition {
    space: string;
    externalId: string;
    version: string;
    usedFor?: "node" | "edge";
    properties: Record<string, ViewDefinitionProperty>;
}
type FilterDefinition = {
    and: FilterDefinition[];
} | {
    or: FilterDefinition[];
} | {
    not: FilterDefinition;
} | {
    equals: {
        property: string[];
        value: string | number | boolean | NodeId;
    };
} | {
    in: {
        property: string[];
        values: (string | number | boolean | NodeId)[];
    };
} | {
    range: {
        property: string[];
        gt?: number | string;
        gte?: number | string;
        lt?: number | string;
        lte?: number | string;
    };
} | {
    exists: {
        property: string[];
    };
} | {
    prefix: {
        property: string[];
        value: string;
    };
} | {
    containsAll: {
        property: string[];
        values: (string | number | boolean)[];
    };
} | {
    containsAny: {
        property: string[];
        values: (string | number | boolean)[];
    };
} | {
    nested: {
        scope: string[];
        filter: FilterDefinition;
    };
} | {
    instanceReferences: Array<{
        space: string;
        externalId: string;
    }>;
} | {
    hasData: ViewReference[];
};
type TableExpressionFilter = FilterDefinition | {
    and: FilterDefinition[];
};
interface PropertySort {
    property: string[];
    direction: SortDirection;
    nullsFirst: boolean;
}
interface QuerySelectExpression {
    sources?: Array<{
        source: ViewReference;
        properties: string[];
    }>;
}
interface QueryNodeTableExpression {
    nodes: {
        filter?: TableExpressionFilter;
        from?: string;
        direction?: "outwards" | "inwards";
        through?: {
            view: ViewReference;
            identifier: string;
        } | {
            source: ViewReference;
            identifier: string;
        };
    };
    sort?: PropertySort[];
    limit?: number;
}
interface QueryEdgeTableExpression {
    edges: {
        from?: string;
        maxDistance?: number;
        filter?: TableExpressionFilter;
        direction?: "outwards" | "inwards";
    };
    sort?: PropertySort[];
    limit?: number;
}
type QueryTableExpression = QueryNodeTableExpression | QueryEdgeTableExpression;
interface InstancesQueryRequest {
    with: Record<string, QueryTableExpression>;
    select: Record<string, QuerySelectExpression | Record<string, never>>;
    cursors?: Record<string, string>;
}
interface InstancesApplySource {
    source: ViewReference;
    properties: Record<string, unknown>;
}
interface InstancesApplyNodeWrite {
    instanceType: "node";
    space: string;
    externalId: string;
    existingVersion?: number;
    sources?: InstancesApplySource[];
}
interface InstancesApplyEdgeWrite {
    instanceType: "edge";
    space: string;
    externalId: string;
    type: unknown;
    startNode: NodeId;
    endNode: NodeId;
    existingVersion?: number;
    sources?: InstancesApplySource[];
}
interface InstancesApplyDelete {
    instanceType: "node" | "edge";
    space: string;
    externalId: string;
}
interface InstancesApplyRequest {
    items: Array<InstancesApplyNodeWrite | InstancesApplyEdgeWrite>;
    delete?: InstancesApplyDelete[];
    replace?: boolean;
}
interface InstancesApplyResultItem {
    instanceType: "node" | "edge";
    version?: number;
    wasModified?: boolean;
    space: string;
    externalId: string;
    createdTime?: number;
    lastUpdatedTime?: number;
}
interface InstancesApplyResponse {
    items: InstancesApplyResultItem[];
}
interface NodeDefinition {
    instanceType: "node";
    version?: number;
    space: string;
    externalId: string;
    properties?: Record<string, Record<string, Record<string, unknown>>>;
    createdTime?: number;
    deletedTime?: number;
    lastUpdatedTime?: number;
}
interface EdgeDefinition {
    instanceType: "edge";
    version?: number;
    space: string;
    externalId: string;
    type?: {
        space: string;
        externalId: string;
    };
    startNode: {
        space: string;
        externalId: string;
    };
    endNode: {
        space: string;
        externalId: string;
    };
    properties?: Record<string, Record<string, Record<string, unknown>>>;
    createdTime?: number;
    deletedTime?: number;
    lastUpdatedTime?: number;
}
type NodeOrEdge = NodeDefinition | EdgeDefinition;
interface InstancesQueryResponse {
    items: Record<string, NodeOrEdge[]>;
    nextCursor: Record<string, string>;
}
interface InstancesSearchRequest {
    view: ViewReference;
    query: string;
    instanceType: "node" | "edge";
    properties: string[];
    operator?: "OR" | "AND";
    filter?: FilterDefinition;
    limit?: number;
}
interface InstancesSearchResponse {
    items: NodeOrEdge[];
}
interface DataModelRetrieveItem {
    views?: ViewDefinition[];
    createdTime: number;
}
interface DataModelRetrieveOptions {
    inlineViews?: boolean;
}
type AggregateFunctionName = "avg" | "min" | "max" | "sum" | "count";
type InstancesAggregateDefinition = {
    avg: {
        property: string;
    };
} | {
    min: {
        property: string;
    };
} | {
    max: {
        property: string;
    };
} | {
    sum: {
        property: string;
    };
} | {
    count: {
        property?: string;
    };
};
interface InstancesAggregateRequest {
    view: ViewReference;
    instanceType: "node";
    limit: number;
    filter?: FilterDefinition;
    groupBy?: string[];
    aggregates?: InstancesAggregateDefinition[];
}
interface InstancesAggregateValue {
    aggregate: AggregateFunctionName;
    property?: string;
    value?: number;
}
interface InstancesAggregateResultItem {
    aggregates: InstancesAggregateValue[];
    group?: Record<string, string | number | boolean | {
        space: string;
        externalId: string;
    }>;
    instanceType: "node" | "edge";
}
interface InstancesAggregateResponse {
    items: InstancesAggregateResultItem[];
}

/** Numeric datapoint from a raw (non-aggregate) time series query. */
type CogniteDoubleDatapoint = {
    timestamp: Date;
    value: number;
};
/** Numeric datapoint from an aggregate time series query.
 *  Each field corresponds to one aggregate function as defined by the Cognite API. */
type CogniteAggregateDatapoint = {
    timestamp: Date;
} & {
    [K in DatapointAggregate]?: number;
};
/** A numeric datapoint as returned by the Cognite API.
 *  String time series datapoints are excluded — they are filtered out before processing. */
type CogniteNumericDatapoint = CogniteDoubleDatapoint | CogniteAggregateDatapoint;
interface CogniteDatapointResultItem {
    space?: string;
    externalId?: string;
    isString: boolean;
    unit?: string;
    datapoints: CogniteNumericDatapoint[];
    nextCursor?: string;
}
interface CogniteDatapointRetrieveItem extends NodeId {
    start?: string | number | Date;
    end?: string | number | Date;
    limit?: number;
    cursor?: string;
    aggregates?: DatapointAggregate[];
    granularity?: string;
    includeOutsidePoints?: boolean;
    targetUnit?: string;
    targetUnitSystem?: string;
    timeZone?: string;
}
interface CogniteDatapointRetrieveOptions {
    items: CogniteDatapointRetrieveItem[];
    start?: string | number | Date;
    end?: string | number | Date;
    limit?: number;
    aggregates?: DatapointAggregate[];
    granularity?: string;
    includeOutsidePoints?: boolean;
    ignoreUnknownIds?: boolean;
    timeZone?: string;
}
interface CogniteDatapointLatestItem extends NodeId {
    before?: string | Date | number;
}
interface CogniteDatapointInsertItem extends NodeId {
    datapoints: Array<{
        timestamp: number | Date;
        value: number;
    }>;
}
interface CogniteDatapointDeleteItem extends NodeId {
    inclusiveBegin: number | Date;
    exclusiveEnd?: number | Date;
}
interface CogniteFileInstanceId {
    space?: string;
    externalId?: string;
}
interface CogniteFileInfo {
    instanceId?: CogniteFileInstanceId;
    name: string;
    uploaded: boolean;
    uploadedTime?: Date;
    createdTime: Date;
    lastUpdatedTime: Date;
    mimeType?: string;
    directory?: string;
    source?: string;
}
interface CogniteFileUploadResult extends CogniteFileInfo {
    uploadUrl?: string;
}
interface CogniteFileUploadInfo {
    instanceId: {
        space: string;
        externalId: string;
    };
    name: string;
    mimeType?: string;
    directory?: string;
    source?: string;
    metadata?: Record<string, string>;
}
interface CogniteFileDownloadUrl {
    instanceId?: CogniteFileInstanceId;
    downloadUrl: string;
}

interface CognitePort {
    retrieveDataModels(ids: DataModelId[], options?: DataModelRetrieveOptions): Promise<{
        items: DataModelRetrieveItem[];
    }>;
    retrieveViews(ids: Array<{
        space: string;
        externalId: string;
        version: string;
    }>): Promise<{
        items: ViewDefinition[];
    }>;
    queryInstances(request: InstancesQueryRequest): Promise<InstancesQueryResponse>;
    searchInstances(request: InstancesSearchRequest): Promise<InstancesSearchResponse>;
    aggregateInstances(request: InstancesAggregateRequest): Promise<InstancesAggregateResponse>;
    applyInstances(request: InstancesApplyRequest): Promise<InstancesApplyResponse>;
    retrieveDatapoints(options: CogniteDatapointRetrieveOptions): Promise<{
        items: CogniteDatapointResultItem[];
    }>;
    retrieveLatestDatapoints(items: CogniteDatapointLatestItem[], options?: {
        ignoreUnknownIds?: boolean;
    }): Promise<{
        items: CogniteDatapointResultItem[];
    }>;
    insertDatapoints(items: CogniteDatapointInsertItem[]): Promise<void>;
    deleteDatapoints(items: CogniteDatapointDeleteItem[]): Promise<void>;
    uploadFile(fileInfo: CogniteFileUploadInfo, content?: unknown): Promise<CogniteFileUploadResult>;
    getFileDownloadUrls(ids: Array<{
        instanceId: {
            space: string;
            externalId: string;
        };
    }>): Promise<CogniteFileDownloadUrl[]>;
}

declare class ViewMapper {
    private readonly cognite;
    private readonly dataModelId;
    private readonly resolver;
    constructor(cognite: CognitePort, dataModelId: DataModelId);
    getView(externalId: string): Promise<ViewDefinition>;
    getViews(): Promise<ViewDefinition[]>;
    protected loadViews(): Promise<Map<string, ViewDefinition>>;
    private cacheKey;
    private fetchViews;
    private loadDependencyViews;
}
/**
 * A `ViewMapper` preloaded with view definitions captured at package generation
 * time. `getView` / `getViews` never call CDF.
 */
declare class ViewMapperCache extends ViewMapper {
    private readonly viewsByExternalId;
    constructor(views: Iterable<ViewDefinition> | Map<string, ViewDefinition>);
    static fromViews(views: readonly object[]): ViewMapperCache;
    protected loadViews(): Promise<Map<string, ViewDefinition>>;
}

type NodeId = {
    externalId: string;
    space: string;
};
type DataModelId = NodeId & {
    version: string;
};
type SortDirection = "ascending" | "descending";
type IndustrialModelClientOptions = {
    validateResults?: boolean;
    /** Preloaded view definitions. When set, the client does not fetch views from CDF. */
    viewMapperCache?: ViewMapperCache;
};
type Simplify<T> = {
    [K in keyof T]: T[K];
} & {};
type Merge<A, B> = Simplify<Omit<A, keyof B> & B>;
type NonNull<T> = Exclude<T, null | undefined>;
type ArrayItem<T> = T extends readonly (infer U)[] ? U : never;
type QueryDepth = 0 | 1 | 2 | 3;
type PrevDepth = {
    0: 0;
    1: 0;
    2: 1;
    3: 2;
};
declare const MODEL_RELATIONS: unique symbol;
declare const MODEL_INSTANCE_TYPE: unique symbol;
type IndustrialModel<TProps, TRelations = {}, TInstanceType extends "node" | "edge" = "node"> = Simplify<TProps & {
    readonly [MODEL_RELATIONS]?: TRelations;
    readonly [MODEL_INSTANCE_TYPE]?: TInstanceType;
}>;
type ModelProps<TModel> = Simplify<Omit<TModel, typeof MODEL_RELATIONS | typeof MODEL_INSTANCE_TYPE>>;
type ModelRelations<TModel> = TModel extends {
    readonly [MODEL_RELATIONS]?: infer TRelations;
} ? NonNull<TRelations> : never;
type RelationKeys<TModel> = [ModelRelations<TModel>] extends [never] ? never : keyof ModelRelations<TModel>;
type IsOptionalKey<T, K extends PropertyKey> = K extends keyof T ? {} extends Pick<T, K> ? true : false : false;
type UnwrapRelationTarget<T> = NonNull<T> extends readonly unknown[] ? ArrayItem<NonNull<T>> : NonNull<T>;
type BaseSelectFor<T, TDepth extends QueryDepth = 3> = [NonNull<T>] extends [NodeId] ? boolean : NonNull<T> extends readonly unknown[] ? [ArrayItem<NonNull<T>>] extends [NodeId] ? boolean : TDepth extends 0 ? boolean : NonNull<ArrayItem<NonNull<T>>> extends object ? boolean | QuerySelect<NonNull<ArrayItem<NonNull<T>>>, PrevDepth[TDepth]> : boolean : TDepth extends 0 ? boolean : NonNull<T> extends object ? boolean | QuerySelect<NonNull<T>, PrevDepth[TDepth]> : boolean;
type RelationSelectFor<T, TDepth extends QueryDepth = 3> = TDepth extends 0 ? never : QuerySelect<UnwrapRelationTarget<T>, PrevDepth[TDepth]>;
type QuerySelectValue<TModel, K extends PropertyKey, TDepth extends QueryDepth> = K extends RelationKeys<TModel> ? K extends keyof ModelProps<TModel> ? boolean | RelationSelectFor<ModelRelations<TModel>[K], TDepth> : RelationSelectFor<ModelRelations<TModel>[K], TDepth> : K extends keyof ModelProps<TModel> ? BaseSelectFor<ModelProps<TModel>[K], TDepth> : never;
type QuerySelect<TModel, TDepth extends QueryDepth = 3> = {
    _all?: true;
} & {
    [K in keyof ModelProps<TModel> | RelationKeys<TModel>]?: QuerySelectValue<TModel, K, TDepth>;
};
type ModelInstanceType<TModel> = TModel extends {
    readonly [MODEL_INSTANCE_TYPE]?: "edge";
} ? "edge" : "node";
type SortInput<TModel> = {
    [K in keyof ModelProps<TModel> as NonNull<ModelProps<TModel>[K]> extends string | number | boolean | Date | NodeId ? K : never]?: SortDirection;
} & (ModelInstanceType<TModel> extends "edge" ? {
    startNode?: SortDirection;
    endNode?: SortDirection;
    type?: SortDirection;
} : {});
type QueryOptions<TModel, TSelect extends QuerySelect<TModel> | undefined = QuerySelect<TModel> | undefined> = {
    viewExternalId: string;
    select?: TSelect;
    filters?: WhereInput<TModel>;
    sort?: SortInput<TModel>;
    limit?: number;
    cursor?: string | null;
};
type NodeResultMetadata = Pick<NodeDefinition, "space" | "externalId" | "version" | "createdTime" | "deletedTime" | "lastUpdatedTime">;
type EdgeResultMetadata = Pick<EdgeDefinition, "space" | "externalId" | "version" | "createdTime" | "deletedTime" | "lastUpdatedTime" | "type" | "startNode" | "endNode">;
type QueryResultMetadata<TModel = unknown> = ModelInstanceType<TModel> extends "edge" ? EdgeResultMetadata : NodeResultMetadata;
type ResultShapeForKey<TModel, K extends PropertyKey> = K extends keyof ModelProps<TModel> ? ModelProps<TModel>[K] : K extends RelationKeys<TModel> ? ModelRelations<TModel>[K] : never;
type ResultEntityForKey<TModel, K extends PropertyKey> = K extends RelationKeys<TModel> ? ModelRelations<TModel>[K] : K extends keyof ModelProps<TModel> ? ModelProps<TModel>[K] : never;
type WrapResultValue<TShape, TValue> = [NonNull<TShape>] extends [readonly unknown[]] ? TValue[] : TValue;
type AsQuerySelect<TModel, TSelect> = TSelect extends QuerySelect<TModel> ? TSelect : never;
type SelectedValue<TModel, K extends PropertyKey, TValue, TDepth extends QueryDepth> = TValue extends true ? K extends keyof ModelProps<TModel> ? ModelProps<TModel>[K] : never : TDepth extends 0 ? never : TValue extends object ? WrapResultValue<ResultShapeForKey<TModel, K>, QueryResultItem<UnwrapRelationTarget<ResultEntityForKey<TModel, K>>, AsQuerySelect<UnwrapRelationTarget<ResultEntityForKey<TModel, K>>, TValue>, PrevDepth[TDepth]>> : never;
type ExplicitSelectionResult<TModel, TSelect, TDepth extends QueryDepth> = Simplify<{
    [K in keyof NonNull<TSelect> as K extends "_all" ? never : SelectedValue<TModel, K, NonNull<TSelect>[K], TDepth> extends never ? never : IsOptionalKey<ModelProps<TModel>, K> extends true ? never : IsOptionalKey<ModelRelations<TModel>, K> extends true ? never : K]-?: SelectedValue<TModel, K, NonNull<TSelect>[K], TDepth>;
} & {
    [K in keyof NonNull<TSelect> as K extends "_all" ? never : SelectedValue<TModel, K, NonNull<TSelect>[K], TDepth> extends never ? never : IsOptionalKey<ModelProps<TModel>, K> extends true ? K : IsOptionalKey<ModelRelations<TModel>, K> extends true ? K : never]?: SelectedValue<TModel, K, NonNull<TSelect>[K], TDepth>;
}>;
type QueryResultItem<TModel, TSelect extends QuerySelect<TModel> | undefined = undefined, TDepth extends QueryDepth = 3> = [TSelect] extends [undefined] ? Merge<QueryResultMetadata<TModel>, ModelProps<TModel>> : Merge<TSelect extends {
    _all: true;
} ? Merge<QueryResultMetadata<TModel>, ModelProps<TModel>> : QueryResultMetadata<TModel>, ExplicitSelectionResult<TModel, TSelect, TDepth>>;
type QueryResult<TItem = Record<string, unknown>> = {
    items: TItem[];
    cursor: string | null;
};
type QueryExecutor<TModel> = {
    <const TSelect extends QuerySelect<TModel>>(options: Omit<QueryOptions<TModel, TSelect>, "select"> & {
        select: TSelect & QuerySelect<TModel>;
    }): Promise<QueryResult<QueryResultItem<TModel, TSelect>>>;
    (options: Omit<QueryOptions<TModel, undefined>, "select"> & {
        select?: undefined;
    }): Promise<QueryResult<QueryResultItem<TModel, undefined>>>;
};
type GroupableValue<T> = [NonNull<T>] extends [NodeId] ? true : [NonNull<T>] extends [readonly NodeId[]] ? true : [NonNull<T>] extends [string | number | boolean] ? true : [NonNull<T>] extends [readonly string[]] ? true : [NonNull<T>] extends [readonly number[]] ? true : [NonNull<T>] extends [readonly boolean[]] ? true : false;
type GroupByKey<TModel> = {
    [K in keyof ModelProps<TModel>]: GroupableValue<ModelProps<TModel>[K]> extends true ? K : never;
}[keyof ModelProps<TModel>];
type AggregateGroupBy<TModel> = {
    [K in GroupByKey<TModel>]?: true;
};
type NumericKey<TModel> = {
    [K in keyof ModelProps<TModel>]: [NonNull<ModelProps<TModel>[K]>] extends [number] ? K : never;
}[keyof ModelProps<TModel>];
type ScalarGroupByKey<TModel> = {
    [K in keyof ModelProps<TModel>]: GroupableValue<ModelProps<TModel>[K]> extends true ? [NonNull<ModelProps<TModel>[K]>] extends [readonly unknown[]] ? never : K : never;
}[keyof ModelProps<TModel>];
type CountableKey<TModel> = ScalarGroupByKey<TModel> | "externalId" | "space";
type AggregateDefinition<TModel> = {
    avg: NumericKey<TModel>;
} | {
    min: NumericKey<TModel>;
} | {
    max: NumericKey<TModel>;
} | {
    sum: NumericKey<TModel>;
} | {
    count: CountableKey<TModel> | Record<string, never>;
};
type SelectedGroupKeys<TGroupBy> = Extract<{
    [K in keyof TGroupBy & string]: TGroupBy[K] extends true ? K : never;
}[keyof TGroupBy & string], string>;
/** Cognite explodes list properties: each group row carries a single element, not an array. */
type GroupValueForProp<T> = NonNull<T> extends readonly unknown[] ? NonNull<T> extends readonly NodeId[] ? NodeId : ArrayItem<NonNull<T>> : T;
type GroupValues<TModel, TGroupBy extends AggregateGroupBy<TModel> | undefined> = TGroupBy extends AggregateGroupBy<TModel> ? Simplify<{
    [K in SelectedGroupKeys<TGroupBy> & keyof ModelProps<TModel>]: GroupValueForProp<ModelProps<TModel>[K]>;
}> : undefined;
type AggregateValue<TDef> = TDef extends {
    avg: infer P extends PropertyKey;
} ? {
    aggregate: "avg";
    property: P;
    value: number;
} : TDef extends {
    min: infer P extends PropertyKey;
} ? {
    aggregate: "min";
    property: P;
    value: number;
} : TDef extends {
    max: infer P extends PropertyKey;
} ? {
    aggregate: "max";
    property: P;
    value: number;
} : TDef extends {
    sum: infer P extends PropertyKey;
} ? {
    aggregate: "sum";
    property: P;
    value: number;
} : TDef extends {
    count: infer P;
} ? Record<string, never> extends P ? {
    aggregate: "count";
    value: number;
} : {
    aggregate: "count";
    property: P;
    value: number;
} : never;
/** Request-order slots. A missing Cognite `value` is `undefined` in that index. */
type AggregateValuesTuple<TAggregates> = TAggregates extends readonly unknown[] ? {
    readonly [I in keyof TAggregates]: AggregateValue<TAggregates[I]> | undefined;
} : undefined;
type NormalizedAggregates<T> = [T] extends [undefined] ? undefined : T extends readonly unknown[] ? T : readonly [T];
type ResolvedAggregateDefs<TOptions> = TOptions extends {
    aggregates: infer A;
} ? NormalizedAggregates<A> : TOptions extends {
    aggregate: infer D;
} ? readonly [D] : undefined;
type FirstAggregateValue<TAggregates> = TAggregates extends readonly [infer First, ...unknown[]] ? AggregateValue<First> : TAggregates extends readonly (infer Element)[] ? AggregateValue<Element> : undefined;
type AggregateOptions<TModel> = {
    viewExternalId: string;
    filters?: WhereInput<TModel>;
    groupBy?: AggregateGroupBy<TModel>;
    /**
     * One or more Cognite aggregate ops (order preserved in the request and results).
     * A single definition may be passed as an object: `aggregates: { count: {} }`.
     */
    aggregates?: AggregateDefinition<TModel> | readonly AggregateDefinition<TModel>[];
    /**
     * @deprecated Use `aggregates`. Still accepted as a single-op alias.
     * Cannot be set together with `aggregates`.
     */
    aggregate?: AggregateDefinition<TModel>;
};
type AggregateResultItem<TModel, TGroupBy extends AggregateGroupBy<TModel> | undefined = undefined, TAggregates extends readonly AggregateDefinition<TModel>[] | undefined = undefined> = {
    group?: GroupValues<TModel, TGroupBy>;
} & ([TAggregates] extends [undefined] ? {
    aggregates?: undefined;
    aggregate?: undefined;
} : {
    aggregates: AggregateValuesTuple<TAggregates>;
    /** @deprecated Prefer `aggregates[0]`. First requested op, when that slot has a value. */
    aggregate?: FirstAggregateValue<TAggregates>;
});
type AggregateResultItemForOptions<TModel, TOptions extends AggregateOptions<TModel>> = AggregateResultItem<TModel, TOptions["groupBy"], ResolvedAggregateDefs<TOptions>>;
type AggregateResult<TItem = Record<string, unknown>> = {
    items: TItem[];
};
type AggregateExecutor<TModel> = <const TOptions extends AggregateOptions<TModel>>(options: TOptions) => Promise<AggregateResult<AggregateResultItemForOptions<TModel, TOptions>>>;
type RelationReferenceValue<T> = [NonNull<T>] extends [readonly unknown[]] ? NodeId[] : NodeId;
type NodeIdLike = {
    space: string;
    externalId: string;
};
type ArrayReferencePropertyKeys<TModel> = {
    [K in keyof ModelProps<TModel>]: [NonNull<ModelProps<TModel>[K]>] extends [readonly unknown[]] ? [ArrayItem<NonNull<ModelProps<TModel>[K]>>] extends [NodeIdLike] ? K : never : never;
}[keyof ModelProps<TModel>];
type ArrayRelationKeys<TModel> = {
    [K in RelationKeys<TModel>]: [NonNull<ModelRelations<TModel>[K]>] extends [readonly unknown[]] ? K : never;
}[RelationKeys<TModel>];
type UpsertProperties<TModel> = Simplify<Partial<ModelProps<TModel>> & {
    [K in RelationKeys<TModel>]?: RelationReferenceValue<ModelRelations<TModel>[K]>;
}>;
type UpsertNode<TModel> = Simplify<NodeId & Partial<Omit<UpsertProperties<TModel>, keyof NodeId>>>;
type EdgeCreationContext = {
    startNode: NodeId;
    endNode: NodeId;
    edgeType: NodeId;
};
type EdgeCreationCallback = (context: EdgeCreationContext) => NodeId;
type EdgeCreationCallbacks<TProperty extends string = string> = Partial<Record<TProperty, EdgeCreationCallback>>;
type OnEdgeCreation<TModel> = EdgeCreationCallbacks<Extract<ArrayReferencePropertyKeys<TModel> | ArrayRelationKeys<TModel>, string>>;
type EdgeMode = "append" | "replace";
type UpsertOptions<TModel> = {
    viewExternalId: string;
    items: UpsertNode<TModel>[];
    onEdgeCreation?: OnEdgeCreation<TModel>;
    replace?: boolean;
    edgeMode?: EdgeMode;
};
type UpsertResultItem = {
    instanceType: "node" | "edge";
    version?: number;
    wasModified?: boolean;
    space: string;
    externalId: string;
    createdTime?: number;
    lastUpdatedTime?: number;
};
type UpsertResult = {
    items: UpsertResultItem[];
};
type UpsertExecutor<TModel> = (options: UpsertOptions<TModel>) => Promise<UpsertResult>;
type DeleteResultItem = Omit<UpsertResultItem, "instanceType"> & {
    instanceType: "node";
};
type DeleteResult = {
    items: DeleteResultItem[];
};
type DeleteExecutor = <TItem extends NodeId>(items: TItem[]) => Promise<DeleteResult>;
type DatapointAggregate = "average" | "max" | "min" | "count" | "sum" | "interpolation" | "stepInterpolation" | "totalVariation" | "continuousVariance" | "discreteVariance";
type RawDatapoint = {
    timestamp: Date;
    value: number;
};
type DatapointSeriesResult = {
    timeSeries: NodeId;
    unit?: string;
    datapoints: RawDatapoint[];
    cursor: string | null;
};
type DatapointsResult = {
    items: DatapointSeriesResult[];
};
type DatapointsRetrieveOptions = {
    timeSeries: NodeId[];
    start?: Date;
    end?: Date;
    /** Number of datapoints to return per time series, or -1 to auto-paginate all pages. */
    limit?: number;
    aggregate?: DatapointAggregate;
    granularity?: string;
    includeOutsidePoints?: boolean;
    ignoreUnknownIds?: boolean;
    timeZone?: string;
};
type DatapointsLatestSeries = NodeId & {
    before?: Date;
};
type DatapointsLatestOptions = {
    timeSeries: DatapointsLatestSeries[];
    ignoreUnknownIds?: boolean;
};
type DatapointsInsertItem = {
    timeSeries: NodeId;
    datapoints: Array<{
        timestamp: Date;
        value: number;
    }>;
};
type DatapointsDeleteRange = {
    timeSeries: NodeId;
    start: Date;
    end?: Date;
};
type DatapointsExecutor = {
    retrieve(options: DatapointsRetrieveOptions): Promise<DatapointsResult>;
    latest(options: DatapointsLatestOptions): Promise<DatapointsResult>;
    insert(items: DatapointsInsertItem[]): Promise<void>;
    delete(ranges: DatapointsDeleteRange[]): Promise<void>;
};
type FileUploadInfo = NodeId & {
    name: string;
    mimeType?: string;
    directory?: string;
    source?: string;
    metadata?: Record<string, string>;
};
type FileUploadResult = NodeId & {
    name: string;
    uploaded: boolean;
    mimeType?: string;
    directory?: string;
    source?: string;
    uploadedTime?: Date;
    createdTime: Date;
    lastUpdatedTime: Date;
    uploadUrl?: string;
};
type FileDownloadUrl = NodeId & {
    downloadUrl: string;
};
type FilesExecutor = {
    upload(fileInfo: FileUploadInfo, content?: unknown): Promise<FileUploadResult>;
    getDownloadUrls(nodeIds: NodeId[]): Promise<FileDownloadUrl[]>;
};
type SearchFilter = {
    query: string;
    operator?: "OR" | "AND";
};
type StringFilters = {
    eq?: string;
    in?: string[];
    prefix?: string;
    search?: SearchFilter;
    exists?: boolean;
};
type NumberFilters = {
    eq?: number;
    in?: number[];
    gt?: number;
    gte?: number;
    lt?: number;
    lte?: number;
    exists?: boolean;
};
type BooleanFilters = {
    eq?: boolean;
    exists?: boolean;
};
type DateFilters = {
    eq?: string | Date;
    in?: Array<string | Date>;
    gt?: string | Date;
    gte?: string | Date;
    lt?: string | Date;
    lte?: string | Date;
    exists?: boolean;
};
type NodeIdFilters = {
    eq?: NodeId;
    in?: NodeId[];
    exists?: boolean;
};
type ListFilters<T> = {
    containsAny?: T[];
    containsAll?: T[];
    exists?: boolean;
} & (T extends string ? {
    search?: SearchFilter;
} : unknown);
type BaseFilterFor<T> = T extends NodeId ? NodeIdFilters : T extends string ? StringFilters : T extends number ? NumberFilters : T extends boolean ? BooleanFilters : T extends Date ? DateFilters : T extends Array<infer U> ? ListFilters<U> : T extends object ? NodeIdFilters | WhereInput<T> : never;
type RelationFilterFor<T> = UnwrapRelationTarget<T> extends object ? WhereInput<UnwrapRelationTarget<T>> : never;
type QueryFilterValue<TModel, K extends PropertyKey> = K extends RelationKeys<TModel> ? K extends keyof ModelProps<TModel> ? BaseFilterFor<ModelProps<TModel>[K]> | RelationFilterFor<ModelRelations<TModel>[K]> : RelationFilterFor<ModelRelations<TModel>[K]> : K extends keyof ModelProps<TModel> ? BaseFilterFor<ModelProps<TModel>[K]> : never;
type WhereInput<TModel> = {
    AND?: WhereInput<TModel> | WhereInput<TModel>[];
    OR?: WhereInput<TModel>[];
    NOT?: WhereInput<TModel> | WhereInput<TModel>[];
} & {
    [K in keyof ModelProps<TModel> | RelationKeys<TModel>]?: QueryFilterValue<TModel, K>;
} & (ModelInstanceType<TModel> extends "edge" ? {
    startNode?: NodeIdFilters;
    endNode?: NodeIdFilters;
    type?: NodeIdFilters;
} : {});

export { type AggregateExecutor as A, type QueryResultItem as B, type QuerySelect as C, type DataModelId as D, type EdgeCreationCallback as E, type FilesExecutor as F, type UpsertNode as G, type UpsertOptions as H, type IndustrialModelClientOptions as I, type UpsertProperties as J, type UpsertResult as K, type UpsertResultItem as L, type ModelProps as M, type NodeId as N, type OnEdgeCreation as O, type CognitePort as P, type QueryExecutor as Q, type RawDatapoint as R, type UpsertExecutor as U, ViewMapperCache as V, type DatapointsExecutor as a, type DeleteResult as b, type AggregateOptions as c, type AggregateResult as d, type AggregateResultItem as e, type AggregateResultItemForOptions as f, type DatapointAggregate as g, type DatapointSeriesResult as h, type DatapointsDeleteRange as i, type DatapointsInsertItem as j, type DatapointsLatestOptions as k, type DatapointsLatestSeries as l, type DatapointsResult as m, type DatapointsRetrieveOptions as n, type DeleteExecutor as o, type DeleteResultItem as p, type EdgeCreationCallbacks as q, type EdgeCreationContext as r, type EdgeMode as s, type FileDownloadUrl as t, type FileUploadInfo as u, type FileUploadResult as v, type IndustrialModel as w, type ModelRelations as x, type QueryOptions as y, type QueryResult as z };