@cargo-ai/api 1.0.1

package/build/src/api/storage/index.js

@@ -0,0 +1,402 @@
+import { getErrorWithReasonErrorMessage } from "../../fetcher/index.js";
+import { Storage } from "../../store/index.js";
+export const buildStorageApi = ({ fetcher, }) => {
+    async function createColumn(payload) {
+        try {
+            await fetcher.fetch({
+                method: "post",
+                endpoint: `/storage/columns`,
+                payload,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodCreateColumnErrorReason, {
+                modelNotFound: "Model not found.",
+                datasetNotFound: "Dataset not found.",
+                duplicateSlug: "Column slug is already used.",
+                aiExpressionNotAllowed: "AI expression is not allowed.",
+                invalidRelationship: "Invalid relationship.",
+            });
+        }
+    }
+    async function updateColumn(payload) {
+        try {
+            await fetcher.fetch({
+                method: "put",
+                endpoint: `/storage/columns`,
+                payload,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodUpdateColumnErrorReason, {
+                modelNotFound: "Model not found.",
+                datasetNotFound: "Dataset not found.",
+                columnNotFound: "Column not found.",
+                aiExpressionNotAllowed: "AI expression is not allowed.",
+                invalidRelationship: "Invalid relationship.",
+            });
+        }
+    }
+    async function removeColumn(payload) {
+        try {
+            await fetcher.fetch({
+                method: "delete",
+                endpoint: `/storage/columns`,
+                payload,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodRemoveColumnErrorReason, {
+                modelNotFound: "Model not found.",
+                datasetNotFound: "Dataset not found.",
+                columnNotFound: "Column not found.",
+            });
+        }
+    }
+    async function reorderColumn(payload) {
+        try {
+            await fetcher.fetch({
+                method: "put",
+                endpoint: `/storage/columns/reorder`,
+                payload,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodReorderColumnErrorReason, {
+                modelNotFound: "Model not found.",
+                columnNotFound: "Column not found.",
+                invalidIndex: "Invalid index.",
+            });
+        }
+    }
+    async function columnExistsBySlug(payload) {
+        const { modelUuid, columnSlug } = payload;
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: `storage/columns/existsBySlug`,
+            params: { slug: columnSlug, modelUuid },
+        });
+        return result;
+    }
+    async function columnAutocomplete(payload) {
+        const { modelUuid, column } = payload;
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: `/storage/columns/autocomplete`,
+                payload: { modelUuid, column },
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodModelColumnAutocompleteErrorReason, {
+                modelNotFound: "Model not found.",
+                datasetNotFound: "Dataset not found.",
+            });
+        }
+    }
+    async function createDataset(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "/storage/datasets",
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodCreateDatasetErrorReason, {
+                connectorNotFound: "Connector not found.",
+                integrationNotFound: "Integration not found.",
+                duplicateSlug: "Slug is already used.",
+            });
+        }
+    }
+    async function allDatasets() {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/storage/datasets/list",
+            payload: {},
+        });
+        return result;
+    }
+    async function getDataset(uuid) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: `/storage/datasets/${uuid}`,
+            payload: {},
+        });
+        return result;
+    }
+    async function allModels() {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/storage/models/list",
+            payload: {},
+        });
+        return result;
+    }
+    async function createModel(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "storage/models",
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodCreateModelErrorReason, {
+                duplicateSlug: "Slug is already used.",
+                connectorNotFound: "Connector not found.",
+                datasetNotFound: "Dataset not found.",
+                datasetNotCompatible: "Dataset is not compatible.",
+                integrationNotCompatible: "Integration not compatible.",
+                integrationNotFound: "Integration not found.",
+                invalidConfig: "Configuration is not valid.",
+                failedToSchedule: "Failed to schedule.",
+            });
+        }
+    }
+    async function updateModel(payload) {
+        const { uuid, ...other } = payload;
+        try {
+            const result = await fetcher.fetch({
+                method: "put",
+                endpoint: `storage/models/${uuid}`,
+                payload: other,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodUpdateModelErrorReason, {
+                modelNotFound: "Model not found.",
+                datasetNotFound: "Dataset not found.",
+                datasetNotCompatible: "Dataset is not compatible.",
+                connectorNotFound: "Connector not found.",
+                integrationNotFound: "Integration not found.",
+                invalidConfig: "Configuration is not valid.",
+                failedToSchedule: "Failed to schedule.",
+            });
+        }
+    }
+    async function syncModel(uuid) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: `storage/models/${uuid}/sync`,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodSyncModelErrorReason, {
+                modelNotFound: "Model not found.",
+                datasetNotFound: "Dataset not found.",
+                connectorNotFound: "Connector not found.",
+                integrationNotFound: "Integration not found.",
+                alreadySyncing: "Already syncing.",
+                failedToSyncFromClient: "Failed to sync.",
+            });
+        }
+    }
+    async function removeModel(uuid) {
+        try {
+            await fetcher.fetch({
+                method: "delete",
+                endpoint: `/storage/models/${uuid}`,
+                payload: {},
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodRemoveModelErrorReason, {
+                modelNotFound: "Model not found.",
+                datasetNotFound: "Dataset not found.",
+                datasetNotCompatible: "Dataset is not compatible.",
+                hasSegments: "Model has related segments.",
+                hasWorkflows: "Model has related workflows.",
+                connectorNotFound: "Connector not found.",
+                integrationNotFound: "Integration not found.",
+                invalidConfig: "Configuration is not valid.",
+            });
+        }
+    }
+    async function modelExistsBySlug(payload) {
+        const { slug, datasetUuid } = payload;
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: `storage/models/existsBySlug`,
+            params: { slug, datasetUuid },
+        });
+        return result;
+    }
+    async function allRelationships() {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/storage/relationships/list",
+        });
+        return result;
+    }
+    async function setRelationships(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "/storage/relationships",
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodSetRelationshipsErrorReason, {
+                datasetNotFound: "Dataset not found.",
+                datasetNotCompatible: "Dataset is not compatible.",
+                invalidRelationships: "Invalid relationships.",
+            });
+        }
+    }
+    async function createRun(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "/storage/runs",
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodCreateRunErrorReason, {
+                modelNotFound: "Model not found.",
+                datasetNotFound: "Dataset not found.",
+                integrationNotFound: "Integration not found.",
+                connectorNotFound: "Connector not found.",
+                modelNotCompatible: "Model is not compatible.",
+                alreadyRunning: "Run already running.",
+                upToDate: "Up to date.",
+                modelIsPaused: "Model is paused.",
+                notEnoughCredits: "Not enough credits.",
+            });
+        }
+    }
+    async function listRuns(payload) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/storage/runs/list",
+            params: payload,
+        });
+        return result;
+    }
+    async function cancelRun(uuid) {
+        try {
+            await fetcher.fetch({
+                method: "post",
+                endpoint: `/storage/runs/${uuid}/cancel`,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodCancelRunErrorReason, {
+                runNotFound: "Run not found.",
+                runAlreadyFinished: "Run already finished.",
+            });
+        }
+    }
+    async function previewModel(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "/storage/models/preview",
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodPreviewModelErrorReason, {
+                datasetNotFound: "Dataset not found.",
+                datasetNotCompatible: "Dataset is not compatible.",
+                connectorNotFound: "Connector not found.",
+                integrationNotFound: "Integration not found.",
+                integrationNotCompatible: "Integration not compatible.",
+                invalidConfig: "Configuration is not valid.",
+            });
+        }
+    }
+    async function previewCountModel(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "/storage/models/previewCount",
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodPreviewCountModelErrorReason, {
+                datasetNotFound: "Dataset not found.",
+                datasetNotCompatible: "Dataset is not compatible.",
+                connectorNotFound: "Connector not found.",
+                integrationNotFound: "Integration not found.",
+                integrationNotCompatible: "Integration not compatible.",
+                invalidConfig: "Configuration is not valid.",
+            });
+        }
+    }
+    async function listRecords(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "get",
+                endpoint: "/storage/records/list",
+                params: payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, Storage.Api.zodListRecordsErrorReason, {
+                modelNotFound: "Model not found.",
+                datasetNotFound: "Dataset not found.",
+                datasetNotCompatible: "Dataset is not compatible.",
+                connectorNotFound: "Connector not found.",
+                integrationNotFound: "Integration not found.",
+                incompatibleWithFetching: "Incompatible with fetching.",
+                incompatibleWithQuery: "Incompatible with command.",
+                incompatibleWithRecordAction: "Incompatible with record action.",
+                integrationNotCompatible: "Integration not compatible",
+                invalidConfig: "Configuration is not valid.",
+            });
+        }
+    }
+    return {
+        column: {
+            create: createColumn,
+            update: updateColumn,
+            remove: removeColumn,
+            reorder: reorderColumn,
+            existsBySlug: columnExistsBySlug,
+            autocomplete: columnAutocomplete,
+        },
+        dataset: {
+            create: createDataset,
+            all: allDatasets,
+            get: getDataset,
+        },
+        model: {
+            all: allModels,
+            create: createModel,
+            update: updateModel,
+            sync: syncModel,
+            remove: removeModel,
+            existsBySlug: modelExistsBySlug,
+            preview: previewModel,
+            previewCount: previewCountModel,
+        },
+        relationship: {
+            all: allRelationships,
+            set: setRelationships,
+        },
+        run: {
+            create: createRun,
+            list: listRuns,
+            cancel: cancelRun,
+        },
+        record: {
+            list: listRecords,
+        },
+    };
+};

package/build/src/api/systemOfRecordIntegration/index.d.ts

@@ -0,0 +1,29 @@
+import type { Fetcher } from "../../fetcher/index.js";
+import { SystemOfRecordIntegration } from "../../store/index.js";
+interface SystemOfRecordIntegrationApiDependencies {
+    fetcher: Fetcher;
+}
+export interface SystemOfRecordIntegrationApi {
+    systemOfRecord: {
+        create: (payload: SystemOfRecordIntegration.Api.CreateSystemOfRecordPayload) => Promise<SystemOfRecordIntegration.Api.CreateSystemOfRecordResult>;
+        get: (uuid: string) => Promise<SystemOfRecordIntegration.Api.GetSystemOfRecordResult>;
+        update: (payload: SystemOfRecordIntegration.Api.UpdateSystemOfRecordPayload) => Promise<SystemOfRecordIntegration.Api.UpdateSystemOfRecordResult>;
+        remove: (uuid: string) => Promise<SystemOfRecordIntegration.Api.RemoveSystemOfRecordResult>;
+        all: () => Promise<SystemOfRecordIntegration.Api.ListSystemOfRecordsResult>;
+        migrate: (payload: SystemOfRecordIntegration.Api.MigratePayload) => Promise<void>;
+        cutover: (payload: SystemOfRecordIntegration.Api.CutoverPayload) => Promise<void>;
+    };
+    client: {
+        getDocumentation: (slug: string) => Promise<string>;
+        query: (command: string) => Promise<SystemOfRecordIntegration.Api.QueryResult>;
+        download: (payload: SystemOfRecordIntegration.Api.DownloadPayload) => Promise<SystemOfRecordIntegration.Api.DownloadResult>;
+        fetch: (payload: SystemOfRecordIntegration.Api.FetchPayload) => Promise<SystemOfRecordIntegration.Api.FetchResult>;
+    };
+    log: {
+        list: (payload: SystemOfRecordIntegration.Api.ListLogsPayload) => Promise<SystemOfRecordIntegration.Api.ListLogsResult>;
+        getMetrics: (payload: SystemOfRecordIntegration.Api.GetMetricsLogsPayload) => Promise<SystemOfRecordIntegration.Api.GetMetricsLogsResult>;
+    };
+}
+export declare const buildSystemOfRecordIntegrationApi: ({ fetcher, }: SystemOfRecordIntegrationApiDependencies) => SystemOfRecordIntegrationApi;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/src/api/systemOfRecordIntegration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/systemOfRecordIntegration/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,UAAU,wCAAwC;IAChD,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,4BAA4B;IAC3C,cAAc,EAAE;QACd,MAAM,EAAE,CACN,OAAO,EAAE,yBAAyB,CAAC,GAAG,CAAC,2BAA2B,KAC/D,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;QACvE,GAAG,EAAE,CACH,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;QACpE,MAAM,EAAE,CACN,OAAO,EAAE,yBAAyB,CAAC,GAAG,CAAC,2BAA2B,KAC/D,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;QACvE,MAAM,EAAE,CACN,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;QACvE,GAAG,EAAE,MAAM,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;QAC5E,OAAO,EAAE,CACP,OAAO,EAAE,yBAAyB,CAAC,GAAG,CAAC,cAAc,KAClD,OAAO,CAAC,IAAI,CAAC,CAAC;QACnB,OAAO,EAAE,CACP,OAAO,EAAE,yBAAyB,CAAC,GAAG,CAAC,cAAc,KAClD,OAAO,CAAC,IAAI,CAAC,CAAC;KACpB,CAAC;IACF,MAAM,EAAE;QACN,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;QACpD,KAAK,EAAE,CACL,OAAO,EAAE,MAAM,KACZ,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACxD,QAAQ,EAAE,CACR,OAAO,EAAE,yBAAyB,CAAC,GAAG,CAAC,eAAe,KACnD,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAC3D,KAAK,EAAE,CACL,OAAO,EAAE,yBAAyB,CAAC,GAAG,CAAC,YAAY,KAChD,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;KACzD,CAAC;IACF,GAAG,EAAE;QACH,IAAI,EAAE,CACJ,OAAO,EAAE,yBAAyB,CAAC,GAAG,CAAC,eAAe,KACnD,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAC3D,UAAU,EAAE,CACV,OAAO,EAAE,yBAAyB,CAAC,GAAG,CAAC,qBAAqB,KACzD,OAAO,CAAC,yBAAyB,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;KAClE,CAAC;CACH;AAED,eAAO,MAAM,iCAAiC,iBAE3C,wCAAwC,KAAG,4BA+N7C,CAAC"}

package/build/src/api/systemOfRecordIntegration/index.js

@@ -0,0 +1,151 @@
+import { getErrorWithReasonErrorMessage } from "../../fetcher/index.js";
+import { SystemOfRecordIntegration } from "../../store/index.js";
+export const buildSystemOfRecordIntegrationApi = ({ fetcher, }) => {
+    async function createSystemOfRecord(payload) {
+        try {
+            const result = await fetcher.fetch({
+                method: "post",
+                endpoint: "/systemOfRecordIntegration/systemOfRecords",
+                payload,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, SystemOfRecordIntegration.Api.zodCreateSystemOfRecordErrorReason, {
+                systemOfRecordAlreadyUsedByAnotherWorkspace: "This system of records is already used by another workspace.",
+                missingPermissions: "Some permissions are missing. Please verify on the documentation that you allowed the necessary permissions.",
+            });
+        }
+    }
+    async function getSystemOfRecord(uuid) {
+        try {
+            const result = await fetcher.fetch({
+                method: "get",
+                endpoint: `/systemOfRecordIntegration/systemOfRecords/${uuid}`,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, SystemOfRecordIntegration.Api.zodUpdateSystemOfRecordErrorReason, {
+                systemOfRecordNotFound: "System of record not found",
+            });
+        }
+    }
+    async function updateSystemOfRecord(payload) {
+        const { uuid, ...other } = payload;
+        try {
+            const result = await fetcher.fetch({
+                method: "put",
+                endpoint: `/systemOfRecordIntegration/systemOfRecords/${uuid}`,
+                payload: other,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, SystemOfRecordIntegration.Api.zodUpdateSystemOfRecordErrorReason, {
+                systemOfRecordNotFound: "System of record not found",
+            });
+        }
+    }
+    async function removeSystemOfRecord(uuid) {
+        try {
+            const result = await fetcher.fetch({
+                method: "delete",
+                endpoint: `/systemOfRecordIntegration/systemOfRecords/${uuid}`,
+            });
+            return result;
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, SystemOfRecordIntegration.Api.zodRemoveSystemOfRecordErrorReason, {
+                systemOfRecordNotFound: "System of record not found",
+            });
+        }
+    }
+    async function allSystemOfRecords() {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/systemOfRecordIntegration/systemOfRecords",
+        });
+        return result;
+    }
+    async function migrateSystemOfRecord(payload) {
+        await fetcher.fetch({
+            method: "post",
+            endpoint: `/systemOfRecordIntegration/systemOfRecords/${payload.uuid}/migrate`,
+        });
+    }
+    async function cutoverSystemOfRecord(payload) {
+        await fetcher.fetch({
+            method: "post",
+            endpoint: `/systemOfRecordIntegration/systemOfRecords/${payload.uuid}/cutover`,
+        });
+    }
+    async function query(command) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: `/systemOfRecordIntegration/clients/query`,
+            payload: { command },
+        });
+        return result;
+    }
+    async function download(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: `/systemOfRecordIntegration/clients/download`,
+            payload,
+        });
+        return result;
+    }
+    async function fetch(payload) {
+        const result = await fetcher.fetch({
+            method: "post",
+            endpoint: "/systemOfRecordIntegration/clients/fetch",
+            payload,
+        });
+        return result;
+    }
+    async function getDocumentation(slug) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: `systemOfRecordIntegration/clients/${slug}/documentation`,
+        });
+        return result.replaceAll("./", `${fetcher.baseUrl}/v1/systemOfRecordIntegration/clients/${slug}/documentation/`);
+    }
+    async function listLogs(payload) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/systemOfRecordIntegration/logs/list",
+            params: payload,
+        });
+        return result;
+    }
+    async function getLogsMetrics(payload) {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/systemOfRecordIntegration/logs/metrics",
+            params: payload,
+        });
+        return result;
+    }
+    return {
+        systemOfRecord: {
+            get: getSystemOfRecord,
+            create: createSystemOfRecord,
+            update: updateSystemOfRecord,
+            remove: removeSystemOfRecord,
+            all: allSystemOfRecords,
+            migrate: migrateSystemOfRecord,
+            cutover: cutoverSystemOfRecord,
+        },
+        client: {
+            getDocumentation,
+            query,
+            download,
+            fetch,
+        },
+        log: {
+            list: listLogs,
+            getMetrics: getLogsMetrics,
+        },
+    };
+};

package/build/src/api/userManagement/index.d.ts

@@ -0,0 +1,14 @@
+import type { Fetcher } from "../../fetcher/index.js";
+import { UserManagement } from "../../store/index.js";
+interface UserManagementApiDependencies {
+    fetcher: Fetcher;
+}
+export interface UserManagementApi {
+    user: {
+        getCurrent: () => Promise<UserManagement.Api.GetCurrentUserResult>;
+        update: (payload: UserManagement.Api.UpdateCurrentUserPayload) => Promise<void>;
+    };
+}
+export declare const buildUserManagementApi: ({ fetcher, }: UserManagementApiDependencies) => UserManagementApi;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/src/api/userManagement/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/userManagement/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,UAAU,6BAA6B;IACrC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;QACnE,MAAM,EAAE,CACN,OAAO,EAAE,cAAc,CAAC,GAAG,CAAC,wBAAwB,KACjD,OAAO,CAAC,IAAI,CAAC,CAAC;KACpB,CAAC;CACH;AAED,eAAO,MAAM,sBAAsB,iBAEhC,6BAA6B,KAAG,iBAwClC,CAAC"}

package/build/src/api/userManagement/index.js

@@ -0,0 +1,33 @@
+import { getErrorWithReasonErrorMessage } from "../../fetcher/index.js";
+import { UserManagement } from "../../store/index.js";
+export const buildUserManagementApi = ({ fetcher, }) => {
+    async function getCurrentUser() {
+        const result = await fetcher.fetch({
+            method: "get",
+            endpoint: "/userManagement/users/current",
+            withoutWorkspace: true,
+        });
+        return result;
+    }
+    async function updateUser(payload) {
+        try {
+            await fetcher.fetch({
+                method: "put",
+                endpoint: "/userManagement/users/current",
+                payload,
+                withoutWorkspace: true,
+            });
+        }
+        catch (error) {
+            throw getErrorWithReasonErrorMessage(error, UserManagement.Api.zodUpdateUserErrorReason, {
+                userNotFound: "User not found.",
+            });
+        }
+    }
+    return {
+        user: {
+            getCurrent: getCurrentUser,
+            update: updateUser,
+        },
+    };
+};

package/build/src/api/workspaceManagement/index.d.ts

@@ -0,0 +1,43 @@
+import type { Fetcher } from "../../fetcher/index.js";
+import { WorkspaceManagement } from "../../store/index.js";
+interface WorkspaceManagementApiDependencies {
+    fetcher: Fetcher;
+}
+export interface WorkspaceManagementApi {
+    workspace: {
+        all: (payload: WorkspaceManagement.Api.AllWorkspacesPayload) => Promise<WorkspaceManagement.Api.AllWorkspacesResult>;
+        create: (payload: WorkspaceManagement.Api.CreateWorkspacePayload) => Promise<WorkspaceManagement.Api.CreateWorkspaceResult>;
+        update: (payload: WorkspaceManagement.Api.UpdateWorkspacePayload) => Promise<WorkspaceManagement.Api.UpdateWorkspaceResult>;
+    };
+    file: {
+        upload: (payload: WorkspaceManagement.Api.UploadFilePayload) => Promise<void>;
+        listColumns: (payload: WorkspaceManagement.Api.ListFileColumnsPayload) => Promise<WorkspaceManagement.Api.ListFileColumnsResult>;
+    };
+    user: {
+        create: (payload: WorkspaceManagement.Api.CreateUserPayload) => Promise<void>;
+        all: (payload: WorkspaceManagement.Api.AllUsersPayload) => Promise<WorkspaceManagement.Api.AllUsersResult>;
+        getCurrent: () => Promise<WorkspaceManagement.Api.GetCurrentUserResult>;
+        remove: (payload: WorkspaceManagement.Api.RemoveUserPayload) => Promise<void>;
+        update: (payload: WorkspaceManagement.Api.UpdateWorkspaceUserPayload) => Promise<void>;
+        upsertPermission: (payload: WorkspaceManagement.Api.UpsertUserPermissionPayload) => Promise<void>;
+        removePermission: (payload: WorkspaceManagement.Api.RemoveUserPermissionPayload) => Promise<void>;
+    };
+    token: {
+        create: (payload: WorkspaceManagement.Api.CreateTokenPayload) => Promise<WorkspaceManagement.Api.CreateTokenResult>;
+        all: () => Promise<WorkspaceManagement.Api.AllTokensResult>;
+        remove: (uuid: string) => Promise<void>;
+    };
+    role: {
+        all: () => Promise<WorkspaceManagement.Api.AllRolesResult>;
+    };
+    folder: {
+        get: (uuid: string) => Promise<WorkspaceManagement.Api.GetFolderResult>;
+        all: () => Promise<WorkspaceManagement.Api.ListFoldersResult>;
+        create: (payload: WorkspaceManagement.Api.CreateFolderPayload) => Promise<WorkspaceManagement.Api.CreateFolderResult>;
+        update: (payload: WorkspaceManagement.Api.UpdateFolderPayload) => Promise<WorkspaceManagement.Api.UpdateFolderResult>;
+        remove: (uuid: string) => Promise<void>;
+    };
+}
+export declare const buildWorkspaceManagementApi: ({ fetcher, }: WorkspaceManagementApiDependencies) => WorkspaceManagementApi;
+export {};
+//# sourceMappingURL=index.d.ts.map