@magda/connector-sdk 1.1.0-arm64.0 → 1.1.0-rc.0

package/dist/index.d.ts

@@ -0,0 +1,1091 @@
+/// <reference types="node" />
+import http = require('http');
+import { default as URI_2 } from 'urijs';
+
+export declare interface AspectBuilder {
+    aspectDefinition: AspectDefinition;
+    builderFunctionString: string;
+    setupFunctionString?: string;
+}
+
+declare class AspectCreationFailure {
+    readonly id: string;
+    readonly error: Error;
+    constructor(id: string, error: Error);
+}
+
+/**
+* A type of aspect in the registry, unique for a tenant.
+*/
+export declare class AspectDefinition {
+    /**
+    * The identifier for the aspect type.
+    */
+    'id': string;
+    /**
+    * The name of the aspect.
+    */
+    'name': string;
+    /**
+    * The JSON Schema of this aspect.
+    */
+    'jsonSchema': any;
+}
+
+declare class AspectDefinitionsApi {
+    protected basePath: string;
+    protected defaultHeaders: any;
+    protected _useQuerystring: boolean;
+    protected authentications: any;
+    constructor(basePath?: string);
+    set useQuerystring(value: boolean);
+    setApiKey(key: AspectDefinitionsApiApiKeys, value: string): void;
+    /**
+     * Create a new aspect
+     *
+     * @param xMagdaTenantId 0
+     * @param aspect The definition of the new aspect.
+     * @param xMagdaSession Magda internal session id
+     */
+    create(xMagdaTenantId: number, aspect: AspectDefinition, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: AspectDefinition;
+    }>;
+    /**
+     * Get a list of all aspects
+     *
+     * @param xMagdaTenantId 0
+     */
+    getAll(xMagdaTenantId: number): Promise<{
+        response: http.IncomingMessage;
+        body: Array<AspectDefinition>;
+    }>;
+    /**
+     * Get an aspect by ID
+     *
+     * @param xMagdaTenantId 0
+     * @param id ID of the aspect to be fetched.
+     */
+    getById(xMagdaTenantId: number, id: string): Promise<{
+        response: http.IncomingMessage;
+        body: AspectDefinition;
+    }>;
+    /**
+     * Modify an aspect by applying a JSON Patch
+     * The patch should follow IETF RFC 6902 (https://tools.ietf.org/html/rfc6902).
+     * @param xMagdaTenantId 0
+     * @param id ID of the aspect to be saved.
+     * @param aspectPatch The RFC 6902 patch to apply to the aspect.
+     * @param xMagdaSession Magda internal session id
+     */
+    patchById(xMagdaTenantId: number, id: string, aspectPatch: Array<Operation>, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: AspectDefinition;
+    }>;
+    /**
+     * Modify an aspect by ID
+     * Modifies the aspect with a given ID.  If an aspect with the ID does not yet exist, it is created.
+     * @param xMagdaTenantId 0
+     * @param id ID of the aspect to be saved.
+     * @param aspect The aspect to save.
+     * @param xMagdaSession Magda internal session id
+     */
+    putById(xMagdaTenantId: number, id: string, aspect: AspectDefinition, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: AspectDefinition;
+    }>;
+}
+
+declare enum AspectDefinitionsApiApiKeys {
+}
+
+declare class AsyncPage<T> {
+    readonly requestNextPage: CreateAsyncPage<T>;
+    readonly data: T;
+    readonly hasData: boolean;
+    static create<T>(next: (data: T) => Promise<T>): AsyncPage<T>;
+    static single<T>(value: T): AsyncPage<T>;
+    static singlePromise<T>(valuePromise: Promise<T>): AsyncPage<T>;
+    static none<T>(): AsyncPage<T>;
+    constructor(data: T, hasData: boolean, requestNextPage: CreateAsyncPage<T>);
+    map<TResult>(selector: (data: T) => TResult): AsyncPage<TResult>;
+    forEach(callback: (data: T) => void): Promise<void>;
+    take(n: number): AsyncPage<T>;
+}
+
+export declare class AuthorizedRegistryClient extends RegistryClient {
+    protected jwt: string;
+    constructor(options: AuthorizedRegistryOptions);
+    putAspectDefinition(aspectDefinition: AspectDefinition, tenantId?: number): Promise<AspectDefinition | Error>;
+    postHook(hook: WebHook): Promise<WebHook | Error>;
+    putHook(hook: WebHook): Promise<WebHook | Error>;
+    getHook(hookId: string): Promise<Maybe<WebHook> | Error>;
+    getHooks(): Promise<WebHook[] | Error>;
+    resumeHook(webhookId: string, succeeded?: boolean, lastEventIdReceived?: string, active?: boolean): Promise<WebHookAcknowledgementResponse | Error>;
+    putRecord(record: Record_2, tenantId?: number): Promise<Record_2 | Error>;
+    putRecordAspect(recordId: string, aspectId: string, aspect: any, tenantId?: number): Promise<Record_2 | Error>;
+    patchRecordAspect(recordId: string, aspectId: string, aspectPatch: Operation[], tenantId?: number): Promise<Record_2 | Error>;
+    deleteBySource(sourceTagToPreserve: string, sourceId: string, tenantId?: number): Promise<MultipleDeleteResult | "Processing" | Error>;
+    getRecordHistory(id: string, pageToken?: string, start?: number, limit?: number): Promise<EventsPage | Error>;
+}
+
+declare interface AuthorizedRegistryJwtOptions extends RegistryOptions {
+    jwt: string;
+    userId?: never;
+    jwtSecret?: never;
+}
+
+export declare type AuthorizedRegistryOptions = AuthorizedRegistryUserIdAndJwtSecretOptions | AuthorizedRegistryJwtOptions;
+
+declare interface AuthorizedRegistryUserIdAndJwtSecretOptions extends RegistryOptions {
+    userId: string;
+    jwtSecret: string;
+    jwt?: never;
+}
+
+export declare abstract class BuilderFunctionParameters {
+    /**
+     * The result of invoking the {@link AspectBuilder#setupFunctionString}, or undefined if there is no
+     * {@link AspectBuilder#setupFunctionString} defined for this builder.
+     *
+     * @type {*}
+     * @memberOf BuilderFunctionParameters
+     */
+    setup: any;
+    /**
+     * The transformer that is building aspects.
+     *
+     * @type {JsonTransformer}
+     * @memberof BuilderFunctionParameters
+     */
+    transformer: JsonTransformer;
+    /**
+     * Reports a non-fatal problem creating an aspect.
+     *
+     * @type {ReportProblem}
+     * @memberOf BuilderFunctionParameters
+     */
+    reportProblem: ReportProblem;
+    /**
+     * Provides access to utility libraries that may be helpful in building aspects.
+     *
+     * @type {BuilderFunctionLibraries}
+     * @memberOf BuilderFunctionParameters
+     */
+    libraries: object;
+    [propName: string]: any;
+}
+
+export declare interface BuilderSetupFunctionParameters {
+    /**
+     * The transformer that is building aspects.
+     *
+     * @type {JsonTransformer}
+     * @memberof BuilderFunctionParameters
+     */
+    transformer: JsonTransformer;
+    /**
+     * Provides access to utility libraries that may be helpful in setting up the builder.
+     *
+     * @type {BuilderFunctionLibraries}
+     * @memberOf BuilderFunctionParameters
+     */
+    libraries: object;
+}
+
+export declare function buildersToCompiledAspects(builders: AspectBuilder[], setupParameters: BuilderSetupFunctionParameters, buildParameters: BuilderFunctionParameters): CompiledAspects;
+
+export declare function cleanOrgTitle(title: string): string;
+
+declare interface CompiledAspect {
+    id: string;
+    builderFunction: Function;
+    setupResult: any;
+}
+
+export declare interface CompiledAspects {
+    parameterNames: string[];
+    parameters: BuilderFunctionParameters;
+    aspects: CompiledAspect[];
+}
+
+export declare class ConnectionResult {
+    aspectDefinitionsConnected: number;
+    organizationsConnected: number;
+    datasetsConnected: number;
+    distributionsConnected: number;
+    recordsTrimmed: number;
+    trimStillProcessing: boolean;
+    aspectDefinitionFailures: AspectCreationFailure[];
+    organizationFailures: RecordCreationFailure[];
+    datasetFailures: RecordCreationFailure[];
+    distributionFailures: RecordCreationFailure[];
+    summarize(): string;
+    static combine(...results: ConnectionResult[]): ConnectionResult;
+}
+
+export declare class ConnectorRecordId {
+    readonly id: string;
+    readonly type: RecordType;
+    readonly sourceId: string;
+    constructor(id: string, type: RecordType, sourceId: string);
+    toString(): string;
+    private get typeId();
+}
+
+export declare interface ConnectorSource {
+    /**
+     * The ID of the source. This is used to prefix IDs of datasets, distributions, and organizations
+     * found in this source.
+     */
+    readonly id: string;
+    /**
+     * The user-friendly name of the source.
+     */
+    readonly name: string;
+    /**
+     * This field is not compulsory and JsonConnector will try to locate its value from commandline parameters
+     * before use ConnectorSource.extras as backup --- more for test cases
+     */
+    readonly extras?: JsonConnectorConfigExtraMetaData;
+    /**
+     * This field is not compulsory and JsonConnector will try to locate its value from commandline parameters
+     * before use ConnectorSource.presetRecordAspects as backup --- more for test cases
+     */
+    readonly presetRecordAspects?: JsonConnectorConfigPresetAspect[];
+    /**
+     * Get all of the datasets as pages of objects.
+     *
+     * @returns {AsyncPage<any[]>} A page of datasets.
+     */
+    getJsonDatasets(): AsyncPage<any[]>;
+    /**
+     * Get a particular dataset given its ID.
+     *
+     * @param {string} id The ID of the dataset.
+     * @returns {Promise<any>} The dataset object with the given ID.
+     */
+    getJsonDataset(id: string): Promise<any>;
+    /**
+     * Search datasets for those that have a particular case-insensitive string
+     * in their title.
+     *
+     * @param {string} title The string to search for the in the title.
+     * @param {number} maxResults The maximum number of results to return.
+     * @returns {AsyncPage<any[]>} A page of matching datasets.
+     */
+    searchDatasetsByTitle(title: string, maxResults: number): AsyncPage<any[]>;
+    /**
+     * Gets the distributions of a given dataset.
+     *
+     * @param {object} dataset The dataset.
+     * @returns {AsyncPage<any[]>} A page of distributions of the dataset.
+     */
+    getJsonDistributions(dataset: any): AsyncPage<any[]>;
+    /**
+     * True if the source provides organizations as first-class objects that can be enumerated and retrieved
+     * by ID.  False if organizations are just fields on datasets or distributions, or if they're not
+     * available at all.
+     */
+    readonly hasFirstClassOrganizations: boolean;
+    /**
+     * Enumerates first-class organizations.  If {@link hasFirstClassOrganizations} is false, this
+     * method returns undefined.
+     *
+     * @returns {AsyncPage<any[]>} A page of organizations, or undefined if first-class organizations are not available.
+     */
+    getJsonFirstClassOrganizations(): AsyncPage<any[]>;
+    /**
+     * Gets a first-class organization by ID. If {@link hasFirstClassOrganizations} is false, this
+     * method returns undefined.
+     *
+     * @param {string} id The ID of the organization to retrieve.
+     * @returns {Promise<any>} A promise for the organization, or undefined if first-class organizations are not available.
+     */
+    getJsonFirstClassOrganization(id: string): Promise<any>;
+    /**
+     * Search first-class organizations for those that have a particular case-insensitive string
+     * in their title.
+     *
+     * @param {string} title The string to search for the in the title.
+     * @param {number} maxResults The maximum number of results to return.
+     * @returns {AsyncPage<any[]>} A page of matching organizations, or undefined if first-class organizations are not available.
+     */
+    searchFirstClassOrganizationsByTitle(title: string, maxResults: number): AsyncPage<any[]>;
+    /**
+     * Gets the ID of the publisher of this dataset.  This method will return undefined if {@link hasFirstClassOrganizations}
+     * is false because non-first-class organizations do not have IDs.
+     *
+     * @param {any} dataset The dataset from which to get the publisher ID.
+     * @returns {string} The ID of the dataset's publisher.
+     */
+    getJsonDatasetPublisherId(dataset: any): string;
+    /**
+     * Gets the publisher organization of this dataset.
+     *
+     * @param {any} dataset The dataset from which to get the publisher.
+     * @returns {Promise<object>} A promise for the organization that published this dataset.
+     */
+    getJsonDatasetPublisher(dataset: any): Promise<any>;
+}
+
+declare class CountResponse {
+    'count': number;
+}
+
+declare interface CreateAsyncPage<T> {
+    (): Promise<AsyncPage<T>>;
+}
+
+declare class DeleteResult {
+    'deleted': boolean;
+}
+
+declare interface Eq<T> {
+    equals(t: T): boolean;
+}
+
+/**
+* A page of events.
+*/
+declare class EventsPage {
+    /**
+    * Whether there are more events available.
+    */
+    'hasMore': boolean;
+    /**
+    * A token to be used to get the next page of events.
+    */
+    'nextPageToken': string;
+    /**
+    * The events in this page.
+    */
+    'events': Array<RegistryEvent>;
+}
+
+/**
+* The type of a registry modification event.
+*/
+declare type EventType = 'CreateRecord' | 'CreateAspectDefinition' | 'CreateRecordAspect' | 'PatchRecord' | 'PatchAspectDefinition' | 'PatchRecordAspect' | 'DeleteRecord' | 'DeleteAspectDefinition' | 'DeleteRecordAspect';
+
+declare interface Functor<T> {
+    fmap<U>(f: (t: T) => U): Functor<U>;
+    lift<U>(f: (t: T) => U): Functor<U>;
+    map<U>(f: (t: T) => U): Functor<U>;
+}
+
+declare class JsObject {
+    'fields': {
+        [key: string]: JsValue;
+    };
+}
+
+/**
+ * A base class for connectors for most any JSON-based catalog source.
+ */
+export declare class JsonConnector {
+    readonly source: ConnectorSource;
+    readonly transformer: JsonTransformer;
+    readonly registry: AuthorizedRegistryClient;
+    readonly maxConcurrency: number;
+    readonly sourceTag?: string;
+    readonly configData?: JsonConnectorConfig;
+    constructor({ source, transformer, registry, maxConcurrency, sourceTag }: JsonConnectorOptions);
+    readConfigData(): JsonConnectorConfig;
+    createAspectDefinitions(): Promise<ConnectionResult>;
+    createOrganization(organizationJson: object): Promise<Record_2 | Error>;
+    createDataset(datasetJson: object): Promise<Record_2 | Error>;
+    createDistribution(distributionJson: object, datasetJson: object): Promise<Record_2 | Error>;
+    createOrganizations(): Promise<ConnectionResult>;
+    createDatasetsAndDistributions(): Promise<ConnectionResult>;
+    trimRecords(): Promise<ConnectionResult>;
+    /**
+     * Runs the connector, creating aspect definitions, organizations, datasets, and distributions in the
+     * registry as necessary.
+     *
+     * @returns {Promise<ConnectionResult>}
+     * @memberof JsonConnector
+     */
+    run(): Promise<ConnectionResult>;
+    runInteractive(options: JsonConnectorRunInteractiveOptions): void;
+    private shutdownOnIdle;
+    putRecord(record: Record_2, recordType: RecordType): Promise<Record_2 | Error>;
+    /**
+     * Copy `extras` from connector config data to
+     * records `source` aspect
+     */
+    private attachConnectorDataToSource;
+    private attachConnectorPresetAspects;
+}
+
+export declare interface JsonConnectorConfig {
+    id: string;
+    name: string;
+    sourceUrl?: string;
+    pageSize?: number;
+    schedule?: string;
+    ignoreHarvestSources?: string[];
+    allowedOrganisationNames?: string[];
+    ignoreOrganisationNames?: string[];
+    extras?: JsonConnectorConfigExtraMetaData;
+    presetRecordAspects?: JsonConnectorConfigPresetAspect[];
+}
+
+/**
+ * Connector extra metadata
+ * Will be copied to records' source aspect automatically
+ */
+declare type JsonConnectorConfigExtraMetaData = {
+    [k: string]: any;
+};
+
+/**
+ * Any aspects that will be `preset` on any records created by the connector
+ *
+ * opType: operation type; Describe how to add the aspect to the record
+ * - MERGE_LEFT: merge `presetAspect` with records aspects.
+ *   i.e. `presetAspect` will be overwritten by records aspects data if any
+ * - MEREG_RIGHT: merge records aspects with `presetAspect`.
+ *   i.e. records aspects data (if any) will be overwritten by `presetAspect`
+ * - REPLACE: `presetAspect` will replace any existing records aspect
+ * - FILL: `presetAspect` will be added if no existing aspect
+ * Default value (If not specified) will be `MERGE_LEFT`
+ *
+ * recordType:
+ * Describes which type of records this aspect will be added to;
+ * If this field is omitted, the aspect will be added to every records.
+ *
+ * data: Object; aspect data
+ */
+declare type JsonConnectorConfigPresetAspect = {
+    id: string;
+    recordType?: RecordType;
+    opType?: "MERGE_LEFT" | "REPLACE" | "FILL" | "MERGE_RIGHT";
+    data: {
+        [k: string]: any;
+    };
+};
+
+export declare interface JsonConnectorOptions {
+    source: ConnectorSource;
+    transformer: JsonTransformer;
+    registry: AuthorizedRegistryClient;
+    maxConcurrency?: number;
+    sourceTag?: string;
+}
+
+export declare interface JsonConnectorRunInteractiveOptions {
+    timeoutSeconds: number;
+    listenPort: number;
+    transformerOptions: any;
+}
+
+/**
+ * A base class for transformers for most any JSON-based catalog source.
+ * A transformer takes source data and transforms it to registry records and aspects.
+ */
+export declare abstract class JsonTransformer {
+    readonly sourceId: string;
+    private datasetAspectBuilders;
+    private distributionAspectBuilders;
+    private organizationAspectBuilders;
+    private organizationAspects;
+    private datasetAspects;
+    private distributionAspects;
+    private tenantId;
+    constructor({ sourceId, libraries, datasetAspectBuilders, distributionAspectBuilders, organizationAspectBuilders }: JsonTransformerOptions);
+    /**
+     * Create a {@link Record} from JSON data representing an organization.
+     *
+     * @param {string} id The ID of the record.
+     * @param {string} name The name of the record.
+     * @param {object} jsonOrganization The JSON data representing the organization.
+     * @returns {Record} The record.
+     *
+     * @memberof JsonConnector
+     */
+    organizationJsonToRecord(jsonOrganization: object): Record_2;
+    datasetJsonToRecord(jsonDataset: object): Record_2;
+    distributionJsonToRecord(jsonDistribution: object, jsonDataset: object): Record_2;
+    getRequiredAspectDefinitions(): AspectDefinition[];
+    abstract getIdFromJsonOrganization(jsonOrganization: any, sourceId: string): ConnectorRecordId;
+    abstract getIdFromJsonDataset(jsonDataset: any, sourceId: string): ConnectorRecordId;
+    abstract getIdFromJsonDistribution(jsonDistribution: any, jsonDataset: any, sourceId: string): ConnectorRecordId;
+    abstract getNameFromJsonOrganization(jsonOrganization: any): string;
+    abstract getNameFromJsonDataset(jsonDataset: any): string;
+    abstract getNameFromJsonDistribution(jsonDistribution: any, jsonDataset: any): string;
+    reviseOrganizationRecord(record: Record_2): Record_2;
+    jsonToRecord(id: ConnectorRecordId, name: string, json: any, aspects: CompiledAspects): Record_2;
+}
+
+export declare interface JsonTransformerOptions {
+    sourceId: string;
+    libraries?: object;
+    datasetAspectBuilders?: AspectBuilder[];
+    distributionAspectBuilders?: AspectBuilder[];
+    organizationAspectBuilders?: AspectBuilder[];
+    maxConcurrency?: number;
+    tenantId: number;
+}
+
+declare class JsValue {
+}
+
+declare class Maybe<T> implements Monad<T>, Functor<T>, Eq<Maybe<T>> {
+    private type;
+    private value;
+    constructor(type: MaybeType, value?: T);
+    static sequence<T>(t: {
+        [k: string]: Maybe<T>;
+    }): Maybe<{
+        [k: string]: T;
+    }>;
+    static all: (t: {
+        [k: string]: Maybe<any>;
+    }) => Maybe<{
+        [k: string]: any;
+    }>;
+    static maybe<T>(t: T): Maybe<T>;
+    static just<T>(t: T): Maybe<T>;
+    static nothing<T>(): Maybe<T>;
+    unit<U>(u: U): Maybe<U>;
+    bind<U>(f: (t: T) => Maybe<U>): Maybe<U>;
+    of: <U>(u: U) => Maybe<U>;
+    chain: <U>(f: (t: T) => Maybe<U>) => Maybe<U>;
+    fmap<U>(f: (t: T) => U): Maybe<U>;
+    lift: <U>(f: (t: T) => U) => Maybe<U>;
+    map: <U>(f: (t: T) => U) => Maybe<U>;
+    caseOf<U>(patterns: MaybePatterns<T, U>): U;
+    defaulting(defaultValue: T): Maybe<T>;
+    equals(other: Maybe<T>): any;
+    valueOr<U extends T>(defaultValue: U): T | U;
+    valueOrCompute<U extends T>(defaultValueFunction: () => U): T | U;
+    valueOrThrow(error?: Error): T;
+    do(patterns?: OptionalMaybePatterns<T, void>): Maybe<T>;
+}
+
+declare interface MaybePatterns<T, U> {
+    just: (t: T) => U;
+    nothing: () => U;
+}
+
+declare enum MaybeType {
+    Nothing = 0,
+    Just = 1,
+}
+
+declare interface Monad<T> {
+    unit<U>(t: U): Monad<U>;
+    bind<U>(f: (t: T) => Monad<U>): Monad<U>;
+    of<U>(t: U): Monad<U>;
+    chain<U>(f: (t: T) => Monad<U>): Monad<U>;
+}
+
+declare class MultipleDeleteResult {
+    'count': number;
+}
+
+declare class Operation {
+}
+
+declare interface OptionalMaybePatterns<T, U> {
+    just?: (t: T) => U;
+    nothing?: () => U;
+}
+
+/**
+* A record in the registry, usually including data for one or more aspects, unique for a tenant.
+*/
+declare class Record_2 {
+    /**
+    * The identifier of the record
+    */
+    'id': string;
+    /**
+    * The name of the record
+    */
+    'name': string;
+    /**
+    * The aspects included in this record
+    */
+    'aspects': any;
+    /**
+    * The read authorization policy id of a record
+    */
+    'authnReadPolicyId': string;
+    /**
+    * A tag representing the action by the source of this record (e.g. an id for a individual crawl of a data portal).
+    */
+    'sourceTag': string;
+    /**
+    * The identifier of a tenant
+    */
+    'tenantId': number;
+}
+export { Record_2 as Record }
+
+declare class RecordAspectsApi {
+    protected basePath: string;
+    protected defaultHeaders: any;
+    protected _useQuerystring: boolean;
+    protected authentications: any;
+    constructor(basePath?: string);
+    set useQuerystring(value: boolean);
+    setApiKey(key: RecordAspectsApiApiKeys, value: string): void;
+    /**
+     * Delete a record aspect by ID
+     * Deletes a record aspect.
+     * @param recordId ID of the record for which to delete an aspect.
+     * @param aspectId ID of the aspect to delete.
+     * @param xMagdaSession Magda internal session id
+     * @param xMagdaTenantId 0
+     */
+    deleteById(recordId: string, aspectId: string, xMagdaSession: string, xMagdaTenantId: number): Promise<{
+        response: http.IncomingMessage;
+        body: DeleteResult;
+    }>;
+    /**
+     * Get a record aspect by ID
+     *
+     * @param xMagdaTenantId 0
+     * @param recordId ID of the record for which to fetch an aspect.
+     * @param aspectId ID of the aspect to fetch.
+     * @param xMagdaSession Magda internal session id
+     */
+    getById(xMagdaTenantId: number, recordId: string, aspectId: string, xMagdaSession?: string): Promise<{
+        response: http.IncomingMessage;
+        body: any;
+    }>;
+    /**
+     * Modify a record aspect by applying a JSON Patch
+     * The patch should follow IETF RFC 6902 (https://tools.ietf.org/html/rfc6902).
+     * @param recordId ID of the record for which to fetch an aspect.
+     * @param aspectId ID of the aspect to fetch.
+     * @param aspectPatch The RFC 6902 patch to apply to the aspect.
+     * @param xMagdaSession Magda internal session id
+     * @param xMagdaTenantId 0
+     */
+    patchById(recordId: string, aspectId: string, aspectPatch: Array<Operation>, xMagdaSession: string, xMagdaTenantId: number): Promise<{
+        response: http.IncomingMessage;
+        body: any;
+    }>;
+    /**
+     * Modify a record aspect by ID
+     * Modifies a record aspect.  If the aspect does not yet exist on this record, it is created.
+     * @param recordId ID of the record for which to update an aspect.
+     * @param aspectId ID of the aspect to update.
+     * @param aspect The record aspect to save.
+     * @param xMagdaSession Magda internal session id
+     * @param xMagdaTenantId 0
+     */
+    putById(recordId: string, aspectId: string, aspect: any, xMagdaSession: string, xMagdaTenantId: number): Promise<{
+        response: http.IncomingMessage;
+        body: any;
+    }>;
+}
+
+declare enum RecordAspectsApiApiKeys {
+}
+
+declare class RecordCreationFailure {
+    readonly id: ConnectorRecordId;
+    readonly parentId: ConnectorRecordId;
+    readonly error: Error;
+    constructor(id: ConnectorRecordId, parentId: ConnectorRecordId, error: Error);
+}
+
+declare class RecordHistoryApi {
+    protected basePath: string;
+    protected defaultHeaders: any;
+    protected _useQuerystring: boolean;
+    protected authentications: any;
+    constructor(basePath?: string);
+    set useQuerystring(value: boolean);
+    setApiKey(key: RecordHistoryApiApiKeys, value: string): void;
+    /**
+     * Get a list of all events affecting this record
+     *
+     * @param xMagdaTenantId 0
+     * @param recordId ID of the record for which to fetch history.
+     * @param xMagdaSession Magda internal session id
+     * @param pageToken A token that identifies the start of a page of events.  This token should not be interpreted as having any meaning, but it can be obtained from a previous page of results.
+     * @param start The index of the first event to retrieve.  When possible, specify pageToken instead as it will result in better performance.  If this parameter and pageToken are both specified, this parameter is interpreted as the index after the pageToken of the first record to retrieve.
+     * @param limit The maximum number of events to receive.  The response will include a token that can be passed as the pageToken parameter to a future request to continue receiving results where this query leaves off.
+     * @param aspect The aspects for which to included in event history, specified as multiple occurrences of this query parameter.
+     * @param dereference true to automatically dereference links to other records; false to leave them as links.  Dereferencing a link means including the record itself where the link would be.  Dereferencing only happens one level deep, regardless of the value of this parameter.
+     */
+    history(xMagdaTenantId: number, recordId: string, xMagdaSession: string, pageToken?: string, start?: number, limit?: number, aspect?: Array<string>, dereference?: boolean): Promise<{
+        response: http.IncomingMessage;
+        body: EventsPage;
+    }>;
+    /**
+     * Get the version of a record that existed after a given event was applied
+     *
+     * @param xMagdaTenantId 0
+     * @param recordId ID of the record to fetch.
+     * @param eventId The ID of the last event to be applied to the record.  The event with this ID need not actually apply to the record, in which case that last event prior to this even that does apply will be used.
+     */
+    version(xMagdaTenantId: number, recordId: string, eventId: string): Promise<{
+        response: http.IncomingMessage;
+        body: Record_2;
+    }>;
+}
+
+declare enum RecordHistoryApiApiKeys {
+}
+
+declare class RecordsApi {
+    protected basePath: string;
+    protected defaultHeaders: any;
+    protected _useQuerystring: boolean;
+    protected authentications: any;
+    constructor(basePath?: string);
+    set useQuerystring(value: boolean);
+    setApiKey(key: RecordsApiApiKeys, value: string): void;
+    /**
+     * Create a new record
+     *
+     * @param xMagdaTenantId 0
+     * @param record The definition of the new record.
+     * @param xMagdaSession Magda internal session id
+     */
+    create(xMagdaTenantId: number, record: Record_2, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: Record_2;
+    }>;
+    /**
+     * Delete a record
+     *
+     * @param xMagdaTenantId 0
+     * @param recordId ID of the record to delete.
+     * @param xMagdaSession Magda internal session id
+     */
+    deleteById(xMagdaTenantId: number, recordId: string, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: DeleteResult;
+    }>;
+    /**
+     * Get a list of all records
+     *
+     * @param xMagdaTenantId 0
+     * @param aspect The aspects for which to retrieve data, specified as multiple occurrences of this query parameter.  Only records that have all of these aspects will be included in the response.
+     * @param optionalAspect The optional aspects for which to retrieve data, specified as multiple occurrences of this query parameter.  These aspects will be included in a record if available, but a record will be included even if it is missing these aspects.
+     * @param pageToken A token that identifies the start of a page of results.  This token should not be interpreted as having any meaning, but it can be obtained from a previous page of results.
+     * @param start The index of the first record to retrieve.  When possible, specify pageToken instead as it will result in better performance.  If this parameter and pageToken are both specified, this parameter is interpreted as the index after the pageToken of the first record to retrieve.
+     * @param limit The maximum number of records to receive.  The response will include a token that can be passed as the pageToken parameter to a future request to continue receiving results where this query leaves off.
+     * @param dereference true to automatically dereference links to other records; false to leave them as links.  Dereferencing a link means including the record itself where the link would be.  Dereferencing only happens one level deep, regardless of the value of this parameter.
+     * @param aspectQuery Filter the records returned by a value within the aspect JSON. Expressed as &#39;aspectId.path.to.field:value&#39;, url encoded. NOTE: This is an early stage API and may change greatly in the future
+     * @param aspectOrQuery Filter the records returned by a value within the aspect JSON. Expressed as &#39;aspectId.path.to.field:value&#39;, url encoded. Queries passing via this parameter will be grouped with OR logic. NOTE: This is an early stage API and may change greatly in the future
+     * @param orderBy Specify the field to sort the result. Aspect field can be supported in a format like aspectId.path.to.field
+     * @param orderByDir Specify the order by direction. Either &#x60;asc&#x60; or &#x60;desc&#x60;
+     * @param orderNullFirst Specify whether nulls appear before (&#x60;true&#x60;) or after (&#x60;false&#x60;) non-null values in the sort ordering.
+     * @param xMagdaSession Magda internal session id
+     */
+    getAll(xMagdaTenantId: number, aspect?: Array<string>, optionalAspect?: Array<string>, pageToken?: string, start?: number, limit?: number, dereference?: boolean, aspectQuery?: Array<string>, aspectOrQuery?: Array<string>, orderBy?: string, orderByDir?: string, orderNullFirst?: boolean, xMagdaSession?: string): Promise<{
+        response: http.IncomingMessage;
+        body: Array<Record_2>;
+    }>;
+    /**
+     * Get a list of all records as summaries
+     *
+     * @param xMagdaTenantId 0
+     * @param pageToken A token that identifies the start of a page of results.  This token should not be interpreted as having any meaning, but it can be obtained from a previous page of results.
+     * @param start The index of the first record to retrieve.  When possible, specify pageToken instead as it will result in better performance.  If this parameter and pageToken are both specified, this parameter is interpreted as the index after the pageToken of the first record to retrieve.
+     * @param limit The maximum number of records to receive.  The response will include a token that can be passed as the pageToken parameter to a future request to continue receiving results where this query leaves off.
+     * @param xMagdaSession Magda internal session id
+     */
+    getAllSummary(xMagdaTenantId: number, pageToken?: string, start?: number, limit?: number, xMagdaSession?: string): Promise<{
+        response: http.IncomingMessage;
+        body: Array<RecordSummary>;
+    }>;
+    /**
+     * Get a record by ID
+     * Gets a complete record, including data for all aspects.
+     * @param id ID of the record to be fetched.
+     * @param xMagdaTenantId 0
+     * @param aspect The aspects for which to retrieve data, specified as multiple occurrences of this query parameter.  Only records that have all of these aspects will be included in the response.
+     * @param optionalAspect The optional aspects for which to retrieve data, specified as multiple occurrences of this query parameter.  These aspects will be included in a record if available, but a record will be included even if it is missing these aspects.
+     * @param dereference true to automatically dereference links to other records; false to leave them as links.  Dereferencing a link means including the record itself where the link would be.  Dereferencing only happens one level deep, regardless of the value of this parameter.
+     * @param xMagdaSession Magda internal session id
+     */
+    getById(id: string, xMagdaTenantId: number, aspect?: Array<string>, optionalAspect?: Array<string>, dereference?: boolean, xMagdaSession?: string): Promise<{
+        response: http.IncomingMessage;
+        body: Record_2;
+    }>;
+    /**
+     * Get a summary record by ID
+     * Gets a summary record, including all the aspect ids for which this record has data.
+     * @param id ID of the record to be fetched.
+     * @param xMagdaTenantId 0
+     * @param xMagdaSession Magda internal session id
+     */
+    getByIdSummary(id: string, xMagdaTenantId: number, xMagdaSession?: string): Promise<{
+        response: http.IncomingMessage;
+        body: RecordSummary;
+    }>;
+    /**
+     * Get the count of records matching the parameters. If no parameters are specified, the count will be approximate for performance reasons.
+     *
+     * @param xMagdaTenantId 0
+     * @param aspect The aspects for which to retrieve data, specified as multiple occurrences of this query parameter.  Only records that have all of these aspects will be included in the response.
+     * @param aspectQuery Filter the records returned by a value within the aspect JSON. Expressed as &#39;aspectId.path.to.field:value&#39;, url encoded. NOTE: This is an early stage API and may change greatly in the future
+     * @param aspectOrQuery Filter the records returned by a value within the aspect JSON. Expressed as &#39;aspectId.path.to.field:value&#39;, url encoded. Queries passing via this parameter will be grouped with OR logic.
+     * @param xMagdaSession Magda internal session id
+     */
+    getCount(xMagdaTenantId: number, aspect?: Array<string>, aspectQuery?: Array<string>, aspectOrQuery?: Array<string>, xMagdaSession?: string): Promise<{
+        response: http.IncomingMessage;
+        body: CountResponse;
+    }>;
+    /**
+     * Get a list tokens for paging through the records
+     *
+     * @param xMagdaTenantId 0
+     * @param aspect The aspects for which to retrieve data, specified as multiple occurrences of this query parameter.  Only records that have all of these aspects will be included in the response.
+     * @param limit The size of each page to get tokens for.
+     * @param xMagdaSession Magda internal session id
+     */
+    getPageTokens(xMagdaTenantId: number, aspect?: Array<string>, limit?: number, xMagdaSession?: string): Promise<{
+        response: http.IncomingMessage;
+        body: Array<string>;
+    }>;
+    /**
+     * Modify a record by applying a JSON Patch
+     * The patch should follow IETF RFC 6902 (https://tools.ietf.org/html/rfc6902).
+     * @param xMagdaTenantId 0
+     * @param id ID of the aspect to be saved.
+     * @param recordPatch The RFC 6902 patch to apply to the aspect.
+     * @param xMagdaSession Magda internal session id
+     */
+    patchById(xMagdaTenantId: number, id: string, recordPatch: Array<Operation>, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: AspectDefinition;
+    }>;
+    /**
+     * Modify a record by ID
+     * Modifies a record.  Aspects included in the request are created or updated, but missing aspects are not removed.
+     * @param xMagdaTenantId 0
+     * @param id ID of the record to be fetched.
+     * @param record The record to save.
+     * @param xMagdaSession Magda internal session id
+     */
+    putById(xMagdaTenantId: number, id: string, record: Record_2, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: Record_2;
+    }>;
+    /**
+     * Trim by source tag
+     * Trims records with the provided source that DON&#39;T have the supplied source tag
+     * @param xMagdaTenantId 0
+     * @param sourceTagToPreserve Source tag of the records to PRESERVE.
+     * @param sourceId Source id of the records to delete.
+     * @param xMagdaSession Magda internal session id
+     */
+    trimBySourceTag(xMagdaTenantId: number, sourceTagToPreserve: string, sourceId: string, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: MultipleDeleteResult;
+    }>;
+}
+
+declare enum RecordsApiApiKeys {
+}
+
+declare interface RecordsPage<I extends Record_2> {
+    totalCount: number;
+    hasMore: boolean;
+    nextPageToken?: string;
+    records: I[];
+}
+
+/**
+* A summary of a record in the registry.  Summaries specify which aspects are available, but do not include data for any aspects.
+*/
+declare class RecordSummary {
+    /**
+    * The identifier of the record
+    */
+    'id': string;
+    /**
+    * The name of the record
+    */
+    'name': string;
+    /**
+    * The list of aspect IDs for which this record has data
+    */
+    'aspects': Array<string>;
+    /**
+    * The identifier of the tenant
+    */
+    'tenantId': number;
+}
+
+declare type RecordType = "Organization" | "Dataset" | "Distribution" | "Group";
+
+declare class RegistryClient {
+    protected baseUri: URI_2;
+    protected aspectDefinitionsApi: AspectDefinitionsApi;
+    protected recordsApi: RecordsApi;
+    protected webHooksApi: WebHooksApi;
+    protected recordAspectsApi: RecordAspectsApi;
+    protected recordHistoryApi: RecordHistoryApi;
+    protected maxRetries: number;
+    protected secondsBetweenRetries: number;
+    protected tenantId: number;
+    protected jwt: string | undefined;
+    constructor({ baseUrl, maxRetries, secondsBetweenRetries, tenantId }: RegistryOptions);
+    getRecordUrl(id: string): string;
+    getAspectDefinitions(): Promise<AspectDefinition[] | Error>;
+    getRecord(id: string, aspect?: Array<string>, optionalAspect?: Array<string>, dereference?: boolean): Promise<Record_2 | Error>;
+    getRecords<I extends Record_2>(aspect?: Array<string>, optionalAspect?: Array<string>, pageToken?: string, dereference?: boolean, limit?: number, aspectQueries?: string[], aspectOrQuery?: string[], orderBy?: string, orderByDir?: string, orderNullFirst?: boolean): Promise<RecordsPage<I> | Error>;
+    getRecordsPageTokens(aspect?: Array<string>, limit?: number): Promise<string[] | Error>;
+}
+
+declare class RegistryEvent {
+    'id': any;
+    'eventTime': Date;
+    'eventType': EventType;
+    'userId': string;
+    'data': JsObject;
+    'tenantId': number;
+}
+
+declare interface RegistryOptions {
+    baseUrl: string;
+    maxRetries?: number;
+    secondsBetweenRetries?: number;
+    tenantId: number;
+}
+
+declare interface ReportProblem {
+    (title: string, message?: string, additionalInfo?: any): void;
+}
+
+export declare const TenantConsts: any;
+
+declare class WebHook {
+    'id': string;
+    'name': string;
+    'active': boolean;
+    'lastEvent': any;
+    'url': string;
+    'eventTypes': Array<EventType>;
+    'isWaitingForResponse': any;
+    'config': WebHookConfig;
+    'enabled': boolean;
+    'lastRetryTime': Date;
+    'retryCount': number;
+    'isRunning': any;
+    'isProcessing': any;
+}
+
+/**
+* Asynchronously acknowledges receipt of a web hook notification.
+*/
+declare class WebHookAcknowledgement {
+    /**
+    * True if the web hook was received successfully and the listener is ready for further notifications.  False if the web hook was not received and the same notification should be repeated.
+    */
+    'succeeded': boolean;
+    /**
+    * The ID of the last event received by the listener.  This should be the value of the `lastEventId` property of the web hook payload that is being acknowledged.  This value is ignored if `succeeded` is false.
+    */
+    'lastEventIdReceived': any;
+    /**
+    * Should the webhook be active or inactive?
+    */
+    'active': any;
+}
+
+/**
+* The response to an asynchronous web hook acknowledgement.
+*/
+declare class WebHookAcknowledgementResponse {
+    /**
+    * The ID of the last event successfully received by the listener.  Further notifications will start after this event.
+    */
+    'lastEventIdReceived': number;
+}
+
+declare class WebHookConfig {
+    'aspects': Array<string>;
+    'optionalAspects': Array<string>;
+    'includeEvents': any;
+    'includeRecords': any;
+    'includeAspectDefinitions': any;
+    'dereference': any;
+}
+
+declare class WebHooksApi {
+    protected basePath: string;
+    protected defaultHeaders: any;
+    protected _useQuerystring: boolean;
+    protected authentications: any;
+    constructor(basePath?: string);
+    set useQuerystring(value: boolean);
+    setApiKey(key: WebHooksApiApiKeys, value: string): void;
+    /**
+     * Acknowledge a previously-deferred web hook
+     * Acknowledges a previously-deferred web hook with a given ID.  Acknowledging a previously-POSTed web hook will cause the next, if any, to be sent.
+     * @param id ID of the web hook to be acknowledged.
+     * @param acknowledgement The details of the acknowledgement.
+     * @param xMagdaSession Magda internal session id
+     */
+    ack(id: string, acknowledgement: WebHookAcknowledgement, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: WebHookAcknowledgementResponse;
+    }>;
+    /**
+     * Create a new web hook
+     *
+     * @param hook The definition of the new web hook.
+     * @param xMagdaSession Magda internal session id
+     */
+    create(hook: WebHook, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: WebHook;
+    }>;
+    /**
+     * Delete a web hook
+     *
+     * @param hookId ID of the web hook to delete.
+     * @param xMagdaSession Magda internal session id
+     */
+    deleteById(hookId: string, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: DeleteResult;
+    }>;
+    /**
+     * Get a list of all web hooks
+     *
+     * @param xMagdaSession Magda internal session id
+     */
+    getAll(xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: Array<WebHook>;
+    }>;
+    /**
+     * Get a web hook by ID
+     *
+     * @param id ID of the web hook to be fetched.
+     * @param xMagdaSession Magda internal session id
+     */
+    getById(id: string, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: WebHook;
+    }>;
+    /**
+     * Modify a web hook by ID
+     * Modifies the web hook with a given ID.  If a web hook with the ID does not yet exist, it is created.
+     * @param id ID of the aspect to be saved.
+     * @param hook The web hook to save.
+     * @param xMagdaSession Magda internal session id
+     */
+    putById(id: string, hook: WebHook, xMagdaSession: string): Promise<{
+        response: http.IncomingMessage;
+        body: WebHook;
+    }>;
+}
+
+declare enum WebHooksApiApiKeys {
+}
+
+export { }