c3nav 3.4.6 → 3.5.0

package/README.md

@@ -1,6 +1,6 @@
 # c3nav [![npm version](https://img.shields.io/npm/v/c3nav.svg)](https://www.npmjs.com/package/c3nav)
 
-A [c3nav](https://c3nav.de) API client. For a documentation on the API see https://c3nav.de/api/.
+A [c3nav](https://c3nav.de) API client. For a documentation on the API see [the c3nav API reference](https://39c3.c3nav.de/api/v2/).
 
 ### Installation
 

package/dist/Endpoints.d.ts

@@ -0,0 +1,112 @@
+export declare const Endpoint: {
+    ACCESSRESTRICTIONGROUPS: string;
+    accessRestrictionGroups(id?: number | string): string;
+    ACCESSRESTRICTIONS: string;
+    accessRestrictions(id?: number | string): string;
+    AREAS: string;
+    areas(id?: number | string): string;
+    BOUNDS: string;
+    BUILDINGS: string;
+    buildings(id?: number | string): string;
+    CHANGESETS: string;
+    changesets(id?: number | string): string;
+    COLUMNS: string;
+    columns(id?: number | string): string;
+    CROSSDESCRIPTIONS: string;
+    crossDescriptions(id?: number | string): string;
+    DETAILS: string;
+    DOORS: string;
+    doors(id?: number | string): string;
+    EDITOR: string;
+    editor(id?: number | string): string;
+    Editor: {
+        beaconsLookup(): string;
+        bounds(): string;
+        geometryStyles(): string;
+        levelGeometries(levelId: number | string): string;
+        spaceGeometries(spaceId: number | string): string;
+    };
+    GEOMETRY: string;
+    HOLES: string;
+    holes(id?: number | string): string;
+    LEAVEDESCRIPTIONS: string;
+    leaveDescriptions(id?: number | string): string;
+    Level: {
+        levels(id?: number | string): string;
+    };
+    LEVELS: string;
+    LINEOBSTACLES: string;
+    lineObstacles(id?: number | string): string;
+    Location: {
+        detail(id: number | string): string;
+        details(id: number | string): string;
+        geometry(id: number | string): string;
+        locations(): string;
+        types(): string;
+    };
+    LOCATIONGROUPCATEGORIES: string;
+    locationGroupCategories(id?: number | string): string;
+    LOCATIONGROUPS: string;
+    locationGroups(id?: number | string): string;
+    LOCATIONS: string;
+    MAP: string;
+    Map: {
+        bounds(): string;
+        legend(themeId: number | string): string;
+        load(): string;
+        locationById(locationId: number | string, full?: boolean): string;
+        locationBySlug(locationSlug: string, full?: boolean): string;
+        locationDisplayById(locationId: number | string): string;
+        locationDisplayBySlug(locationSlug: string): string;
+        locationGeometryById(locationId: number | string): string;
+        locationGeometryBySlug(locationSlug: string): string;
+        locations(full?: boolean): string;
+        myPositions(): string;
+        position(positionId: number | string): string;
+        projection(): string;
+        quests(): string;
+        settings(): string;
+        wifidata(): string;
+    };
+    Mesh: {
+        firmwareById(firmwareId: number): string;
+        firmwares(): string;
+        map(levelId: number): string;
+        messages(): string;
+    };
+    OBSTACLES: string;
+    obstacles(id?: number | string): string;
+    POIS: string;
+    pois(id?: number | string): string;
+    Positioning: {
+        locate(): string;
+        locateTest(): string;
+    };
+    RAMPS: string;
+    ramps(id?: number | string): string;
+    ROUTING: string;
+    routing(id?: number | string): string;
+    Routing: {
+        options(): string;
+        optionsForm(): string;
+        route(): string;
+    };
+    SESSION: string;
+    session(id?: number | string): string;
+    Session: {
+        key(): string;
+        status(): string;
+    };
+    SOURCES: string;
+    sources(id?: number | string): string;
+    SPACES: string;
+    spaces(id?: number | string): string;
+    STAIRS: string;
+    stairs(id?: number | string): string;
+    TYPES: string;
+    UPDATES: string;
+    updates(id?: number | string): string;
+    Updates: {
+        fetch(): string;
+    };
+};

package/dist/Endpoints.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endpoint = void 0;
+const encode = encodeURIComponent;
+function mapDataEndpoint(path, id) {
+    let endpoint = `/api/v2/mapdata/${path}/`;
+    if (id !== undefined) {
+        endpoint += `${encode(String(id))}/`;
+    }
+    return endpoint;
+}
+exports.Endpoint = {
+    ACCESSRESTRICTIONGROUPS: 'accessrestrictiongroups',
+    accessRestrictionGroups(id) {
+        return mapDataEndpoint('accessrestrictiongroups', id);
+    },
+    ACCESSRESTRICTIONS: 'accessrestrictions',
+    accessRestrictions(id) {
+        return mapDataEndpoint('accessrestrictions', id);
+    },
+    AREAS: 'areas',
+    areas(id) {
+        return mapDataEndpoint('areas', id);
+    },
+    BOUNDS: 'bounds',
+    BUILDINGS: 'buildings',
+    buildings(id) {
+        return mapDataEndpoint('buildings', id);
+    },
+    CHANGESETS: 'changesets',
+    changesets(id) {
+        return mapDataEndpoint('changesets', id);
+    },
+    COLUMNS: 'columns',
+    columns(id) {
+        return mapDataEndpoint('columns', id);
+    },
+    CROSSDESCRIPTIONS: 'cross_descriptions',
+    crossDescriptions(id) {
+        return mapDataEndpoint('cross_descriptions', id);
+    },
+    DETAILS: 'display',
+    DOORS: 'doors',
+    doors(id) {
+        return mapDataEndpoint('doors', id);
+    },
+    EDITOR: 'editor',
+    editor(id) {
+        let endpoint = '/api/v2/editor/';
+        if (id !== undefined) {
+            endpoint += `${encode(String(id))}/`;
+        }
+        return endpoint;
+    },
+    Editor: {
+        beaconsLookup() {
+            return '/api/v2/editor/beacons-lookup/';
+        },
+        bounds() {
+            return '/api/v2/editor/bounds/';
+        },
+        geometryStyles() {
+            return '/api/v2/editor/geometrystyles/';
+        },
+        levelGeometries(levelId) {
+            return `/api/v2/editor/geometries/level/${encode(String(levelId))}/`;
+        },
+        spaceGeometries(spaceId) {
+            return `/api/v2/editor/geometries/space/${encode(String(spaceId))}/`;
+        },
+    },
+    GEOMETRY: 'geometry',
+    HOLES: 'holes',
+    holes(id) {
+        return mapDataEndpoint('holes', id);
+    },
+    LEAVEDESCRIPTIONS: 'leave_descriptions',
+    leaveDescriptions(id) {
+        return mapDataEndpoint('leave_descriptions', id);
+    },
+    Level: {
+        levels(id) {
+            return mapDataEndpoint('levels', id);
+        },
+    },
+    LEVELS: 'levels',
+    LINEOBSTACLES: 'lineobstacles',
+    lineObstacles(id) {
+        return mapDataEndpoint('lineobstacles', id);
+    },
+    Location: {
+        detail(id) {
+            if (typeof id === 'string') {
+                return `/api/v2/map/locations/by-slug/${encode(String(id))}/`;
+            }
+            return `/api/v2/map/locations/${encode(String(id))}/`;
+        },
+        details(id) {
+            if (typeof id === 'string') {
+                return `/api/v2/map/locations/by-slug/${encode(String(id))}/display/`;
+            }
+            return `/api/v2/map/locations/${encode(String(id))}/display/`;
+        },
+        geometry(id) {
+            if (typeof id === 'string') {
+                return `/api/v2/map/locations/by-slug/${encode(String(id))}/geometry/`;
+            }
+            return `/api/v2/map/locations/${encode(String(id))}/geometry/`;
+        },
+        locations() {
+            return '/api/v2/map/locations/';
+        },
+        types() {
+            return '/api/v2/locations/types/';
+        },
+    },
+    LOCATIONGROUPCATEGORIES: 'locationgroupcategories',
+    locationGroupCategories(id) {
+        return mapDataEndpoint('locationgroupcategories', id);
+    },
+    LOCATIONGROUPS: 'locationgroups',
+    locationGroups(id) {
+        return mapDataEndpoint('locationgroups', id);
+    },
+    LOCATIONS: 'locations',
+    MAP: 'map',
+    Map: {
+        bounds() {
+            return '/api/v2/map/bounds/';
+        },
+        legend(themeId) {
+            return `/api/v2/map/legend/${encode(String(themeId))}/`;
+        },
+        load() {
+            return '/api/v2/map/load/';
+        },
+        locationById(locationId, full = false) {
+            return full
+                ? `/api/v2/map/locations/${encode(String(locationId))}/full/`
+                : `/api/v2/map/locations/${encode(String(locationId))}/`;
+        },
+        locationBySlug(locationSlug, full = false) {
+            return full
+                ? `/api/v2/map/locations/by-slug/${encode(String(locationSlug))}/full/`
+                : `/api/v2/map/locations/by-slug/${encode(String(locationSlug))}/`;
+        },
+        locationDisplayById(locationId) {
+            return `/api/v2/map/locations/${encode(String(locationId))}/display/`;
+        },
+        locationDisplayBySlug(locationSlug) {
+            return `/api/v2/map/locations/by-slug/${encode(String(locationSlug))}/display/`;
+        },
+        locationGeometryById(locationId) {
+            return `/api/v2/map/locations/${encode(String(locationId))}/geometry/`;
+        },
+        locationGeometryBySlug(locationSlug) {
+            return `/api/v2/map/locations/by-slug/${encode(String(locationSlug))}/geometry/`;
+        },
+        locations(full = false) {
+            return full ? '/api/v2/map/locations/full/' : '/api/v2/map/locations/';
+        },
+        myPositions() {
+            return '/api/v2/map/positions/my/';
+        },
+        position(positionId) {
+            return `/api/v2/map/positions/${encode(String(positionId))}/`;
+        },
+        projection() {
+            return '/api/v2/map/projection/';
+        },
+        quests() {
+            return '/api/v2/map/quests/';
+        },
+        settings() {
+            return '/api/v2/map/settings/';
+        },
+        wifidata() {
+            return '/api/v2/map/wifidata/';
+        },
+    },
+    Mesh: {
+        firmwareById(firmwareId) {
+            return `/api/v2/mesh/firmwares/${encode(String(firmwareId))}/`;
+        },
+        firmwares() {
+            return '/api/v2/mesh/firmwares/';
+        },
+        map(levelId) {
+            return `/api/v2/mesh/map/${encode(String(levelId))}/`;
+        },
+        messages() {
+            return '/api/v2/mesh/messages/';
+        },
+    },
+    OBSTACLES: 'obstacles',
+    obstacles(id) {
+        return mapDataEndpoint('obstacles', id);
+    },
+    POIS: 'pois',
+    pois(id) {
+        return mapDataEndpoint('pois', id);
+    },
+    Positioning: {
+        locate() {
+            return '/api/v2/positioning/locate/';
+        },
+        locateTest() {
+            return '/api/v2/positioning/locate-test/';
+        },
+    },
+    RAMPS: 'ramps',
+    ramps(id) {
+        return mapDataEndpoint('ramps', id);
+    },
+    ROUTING: 'routing',
+    routing(id) {
+        let endpoint = '/api/v2/routing/';
+        if (id !== undefined) {
+            endpoint += `${encode(String(id))}/`;
+        }
+        return endpoint;
+    },
+    Routing: {
+        options() {
+            return '/api/v2/routing/options/';
+        },
+        optionsForm() {
+            return '/api/v2/routing/options/form/';
+        },
+        route() {
+            return '/api/v2/routing/route/';
+        },
+    },
+    SESSION: 'session',
+    session(id) {
+        let endpoint = '/api/v2/auth/session/';
+        if (id !== undefined) {
+            endpoint += `${encode(String(id))}/`;
+        }
+        return endpoint;
+    },
+    Session: {
+        key() {
+            return '/api/v2/auth/session/';
+        },
+        status() {
+            return '/api/v2/auth/status/';
+        },
+    },
+    SOURCES: 'sources',
+    sources(id) {
+        return mapDataEndpoint('sources', id);
+    },
+    SPACES: 'spaces',
+    spaces(id) {
+        return mapDataEndpoint('spaces', id);
+    },
+    STAIRS: 'stairs',
+    stairs(id) {
+        return mapDataEndpoint('stairs', id);
+    },
+    TYPES: 'types',
+    UPDATES: 'updates',
+    updates(id) {
+        let endpoint = '/api/v2/updates/';
+        if (id !== undefined) {
+            endpoint += `${encode(String(id))}/`;
+        }
+        return endpoint;
+    },
+    Updates: {
+        fetch() {
+            return '/api/v2/updates/fetch/';
+        },
+    },
+};

package/dist/api/APIBase.d.ts

@@ -0,0 +1,12 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { ClientOptions } from '../interfaces/';
+export declare class APIBase {
+    protected readonly apiClient: APIClient;
+    protected readonly options: ClientOptions;
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * Set a new API URL.
+     * @param newURL The new API url
+     */
+    setApiUrl(newURL: string): void;
+}

package/dist/api/APIBase.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIBase = void 0;
+class APIBase {
+    constructor(apiClient, options) {
+        this.apiClient = apiClient;
+        this.options = options;
+    }
+    /**
+     * Set a new API URL.
+     * @param newURL The new API url
+     */
+    setApiUrl(newURL) {
+        this.apiClient.setBaseURL(newURL);
+    }
+}
+exports.APIBase = APIBase;

package/dist/api/AccessRestrictionGroupsAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { AccessRestrictionGroups, ClientOptions } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class AccessRestrictionGroupsAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<AccessRestrictionGroups>;
+    getList(): Promise<AccessRestrictionGroups[]>;
+}

package/dist/api/AccessRestrictionGroupsAPI.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessRestrictionGroupsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class AccessRestrictionGroupsAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.accessRestrictionGroups(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.accessRestrictionGroups();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.AccessRestrictionGroupsAPI = AccessRestrictionGroupsAPI;

package/dist/api/AccessRestrictionsAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { AccessRestrictions, ClientOptions } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class AccessRestrictionsAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<AccessRestrictions>;
+    getList(): Promise<AccessRestrictions[]>;
+}

package/dist/api/AccessRestrictionsAPI.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessRestrictionsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class AccessRestrictionsAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.accessRestrictions(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.accessRestrictions();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.AccessRestrictionsAPI = AccessRestrictionsAPI;

package/dist/api/AreasAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { Areas, ClientOptions } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class AreasAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<Areas>;
+    getList(): Promise<Areas[]>;
+}

package/dist/api/AreasAPI.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AreasAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class AreasAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.areas(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.areas();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.AreasAPI = AreasAPI;

package/dist/api/BuildingsAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { Buildings, ClientOptions } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class BuildingsAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<Buildings>;
+    getList(): Promise<Buildings[]>;
+}

package/dist/api/BuildingsAPI.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildingsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class BuildingsAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.buildings(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.buildings();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.BuildingsAPI = BuildingsAPI;

package/dist/api/ChangesetsAPI.d.ts

@@ -0,0 +1,11 @@
+import type { APIClient } from '@ffflorian/api-client';
+import type { Changesets, ClientOptions } from '../interfaces/';
+import { APIBase } from './APIBase';
+export declare class ChangesetsAPI extends APIBase {
+    constructor(apiClient: APIClient, options: ClientOptions);
+    /**
+     * @param id The id to get
+     */
+    getById(id: number): Promise<Changesets>;
+    getList(): Promise<Changesets[]>;
+}

package/dist/api/ChangesetsAPI.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangesetsAPI = void 0;
+const Endpoints_1 = require("../Endpoints");
+const APIBase_1 = require("./APIBase");
+class ChangesetsAPI extends APIBase_1.APIBase {
+    constructor(apiClient, options) {
+        super(apiClient, options);
+    }
+    /**
+     * @param id The id to get
+     */
+    getById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.changesets(id);
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+    getList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = Endpoints_1.Endpoint.changesets();
+            const { data } = yield this.apiClient.get(endpoint);
+            return data;
+        });
+    }
+}
+exports.ChangesetsAPI = ChangesetsAPI;