import { AnalyzeLocationRequest } from '../models/AnalyzeLocationRequest.model';
import { AnalyzeLocationResponse } from '../models/AnalyzeLocationResponse.model';
import { CreateLocation201Response } from '../models/CreateLocation201Response.model';
import { CreateLocationRequest } from '../models/CreateLocationRequest.model';
import { EntitiesBatchResponse } from '../models/EntitiesBatchResponse.model';
import { EntitiesQueryResponse } from '../models/EntitiesQueryResponse.model';
import { Entity } from '../models/Entity.model';
import { EntityAncestryResponse } from '../models/EntityAncestryResponse.model';
import { EntityFacetsResponse } from '../models/EntityFacetsResponse.model';
import { GetEntitiesByRefsRequest } from '../models/GetEntitiesByRefsRequest.model';
import { GetLocations200ResponseInner } from '../models/GetLocations200ResponseInner.model';
import { Location } from '../models/Location.model';
import { RefreshEntityRequest } from '../models/RefreshEntityRequest.model';
import { ValidateEntityRequest } from '../models/ValidateEntityRequest.model';
/**
 * Wraps the Response type to convey a type on the json call.
 *
 * @public
 */
export type TypedResponse<T> = Omit<Response, 'json'> & {
    json: () => Promise<T>;
};
/**
 * Options you can pass into a request for additional information.
 *
 * @public
 */
export interface RequestOptions {
    token?: string;
}
/**
 * no description
 */
export declare class DefaultApiClient {
    private readonly discoveryApi;
    private readonly fetchApi;
    constructor(options: {
        discoveryApi: {
            getBaseUrl(pluginId: string): Promise<string>;
        };
        fetchApi?: {
            fetch: typeof fetch;
        };
    });
    /**
     * Validate a given location.
     * @param analyzeLocationRequest
     */
    analyzeLocation(request: {
        body: AnalyzeLocationRequest;
    }, options?: RequestOptions): Promise<TypedResponse<AnalyzeLocationResponse>>;
    /**
     * Create a location for a given target.
     * @param createLocationRequest
     * @param dryRun
     */
    createLocation(request: {
        body: CreateLocationRequest;
        query: {
            dryRun?: string;
        };
    }, options?: RequestOptions): Promise<TypedResponse<CreateLocation201Response>>;
    /**
     * Delete a single entity by UID.
     * @param uid
     */
    deleteEntityByUid(request: {
        path: {
            uid: string;
        };
    }, options?: RequestOptions): Promise<TypedResponse<void>>;
    /**
     * Delete a location by id.
     * @param id
     */
    deleteLocation(request: {
        path: {
            id: string;
        };
    }, options?: RequestOptions): Promise<TypedResponse<void>>;
    /**
     * Get all entities matching a given filter.
     * @param fields Restrict to just these fields in the response.
     * @param limit Number of records to return in the response.
     * @param filter Filter for just the entities defined by this filter.
     * @param offset Number of records to skip in the query page.
     * @param after Pointer to the previous page of results.
     * @param order
     */
    getEntities(request: {
        query: {
            fields?: Array<string>;
            limit?: number;
            filter?: Array<string>;
            offset?: number;
            after?: string;
            order?: Array<string>;
        };
    }, options?: RequestOptions): Promise<TypedResponse<Array<Entity>>>;
    /**
     * Search for entities by a given query.
     * @param fields Restrict to just these fields in the response.
     * @param limit Number of records to return in the response.
     * @param orderField The fields to sort returned results by.
     * @param cursor Cursor to a set page of results.
     * @param filter Filter for just the entities defined by this filter.
     * @param fullTextFilterTerm Text search term.
     * @param fullTextFilterFields A comma separated list of fields to sort returned results by.
     */
    getEntitiesByQuery(request: {
        query: {
            fields?: Array<string>;
            limit?: number;
            orderField?: Array<string>;
            cursor?: string;
            filter?: Array<string>;
            fullTextFilterTerm?: string;
            fullTextFilterFields?: Array<string>;
        };
    }, options?: RequestOptions): Promise<TypedResponse<EntitiesQueryResponse>>;
    /**
     * Get a batch set of entities given an array of entityRefs.
     * @param getEntitiesByRefsRequest
     */
    getEntitiesByRefs(request: {
        body: GetEntitiesByRefsRequest;
        query?: {
            filter?: Array<string>;
        };
    }, options?: RequestOptions): Promise<TypedResponse<EntitiesBatchResponse>>;
    /**
     * Get an entity's ancestry by entity ref.
     * @param kind
     * @param namespace
     * @param name
     */
    getEntityAncestryByName(request: {
        path: {
            kind: string;
            namespace: string;
            name: string;
        };
    }, options?: RequestOptions): Promise<TypedResponse<EntityAncestryResponse>>;
    /**
     * Get an entity by an entity ref.
     * @param kind
     * @param namespace
     * @param name
     */
    getEntityByName(request: {
        path: {
            kind: string;
            namespace: string;
            name: string;
        };
    }, options?: RequestOptions): Promise<TypedResponse<Entity>>;
    /**
     * Get a single entity by the UID.
     * @param uid
     */
    getEntityByUid(request: {
        path: {
            uid: string;
        };
    }, options?: RequestOptions): Promise<TypedResponse<Entity>>;
    /**
     * Get all entity facets that match the given filters.
     * @param facet
     * @param filter Filter for just the entities defined by this filter.
     */
    getEntityFacets(request: {
        query: {
            facet: Array<string>;
            filter?: Array<string>;
        };
    }, options?: RequestOptions): Promise<TypedResponse<EntityFacetsResponse>>;
    /**
     * Get a location by id.
     * @param id
     */
    getLocation(request: {
        path: {
            id: string;
        };
    }, options?: RequestOptions): Promise<TypedResponse<Location>>;
    /**
     * Get a location for entity.
     * @param kind
     * @param namespace
     * @param name
     */
    getLocationByEntity(request: {
        path: {
            kind: string;
            namespace: string;
            name: string;
        };
    }, options?: RequestOptions): Promise<TypedResponse<Location>>;
    /**
     * Get all locations
     */
    getLocations(request: {}, options?: RequestOptions): Promise<TypedResponse<Array<GetLocations200ResponseInner>>>;
    /**
     * Refresh the entity related to entityRef.
     * @param refreshEntityRequest
     */
    refreshEntity(request: {
        body: RefreshEntityRequest;
    }, options?: RequestOptions): Promise<TypedResponse<void>>;
    /**
     * Validate that a passed in entity has no errors in schema.
     * @param validateEntityRequest
     */
    validateEntity(request: {
        body: ValidateEntityRequest;
    }, options?: RequestOptions): Promise<TypedResponse<void>>;
}
