@hautechai/sdk 1.0.3 → 1.0.4

package/dist/sdk/api.d.ts

@@ -0,0 +1,20 @@
+import { AxiosPromise } from 'axios';
+import { BaseAPI } from '../autogenerated/base';
+import { SDKOptions } from '../types';
+import { Configuration } from '../autogenerated';
+export declare const getBaseUrl: (options: SDKOptions) => string;
+export declare const getAPI: <T>(API: new (configuration?: Configuration, basePath?: string, axios?: any) => T, options: SDKOptions) => Promise<T>;
+export declare const useAutogeneratedAPI: <T extends BaseAPI>(baseProps: {
+    API: new (configuration?: Configuration, basePath?: string, axios?: any) => T;
+    options: SDKOptions;
+}) => {
+    call: <ResponseEntity, ReturnType = ResponseEntity>(props: {
+        returnUndefinedOn404?: boolean;
+        run: (api: T) => AxiosPromise<ResponseEntity>;
+        transform?: (response: ResponseEntity) => ReturnType;
+    }) => Promise<ReturnType>;
+    callWithReturningUndefinedOn404: <ResponseEntity, ReturnType_1 = ResponseEntity>(props: {
+        run: (api: T) => AxiosPromise<ResponseEntity>;
+        transform?: (response: ResponseEntity) => ReturnType_1;
+    }) => Promise<ReturnType_1 | undefined>;
+};

package/dist/sdk/api.js

@@ -0,0 +1,33 @@
+import { HautechError } from './errors';
+export const getBaseUrl = (options) => options.endpoint ?? 'https://api.hautech.ai';
+export const getAPI = async (API, options) => {
+    const config = {
+        accessToken: await options.authToken(),
+        basePath: getBaseUrl(options),
+        isJsonMime: (mime) => true,
+    };
+    return new API(config);
+};
+export const useAutogeneratedAPI = (baseProps) => {
+    const call = async (props) => {
+        const api = await getAPI(baseProps.API, baseProps.options);
+        try {
+            const response = await props.run(api);
+            if (props.returnUndefinedOn404 && response.status === 404)
+                return undefined;
+            if (response.status < 200 || response.status >= 300)
+                throw new HautechError(`API call failed with status code ${response.status}`);
+            return props.transform ? props.transform(response.data) : response.data;
+        }
+        catch (error) {
+            if (props.returnUndefinedOn404 && error?.response?.status === 404)
+                return undefined;
+            throw new HautechError(error.message, { cause: error });
+        }
+    };
+    const callWithReturningUndefinedOn404 = async (props) => call({ ...props, returnUndefinedOn404: true });
+    return {
+        call,
+        callWithReturningUndefinedOn404,
+    };
+};

package/dist/sdk/balances/index.d.ts

@@ -0,0 +1,12 @@
+import { SDKOptions } from '../../types';
+declare const balances: (options: SDKOptions) => {
+    add: (props: {
+        accountId: string;
+        amount: string;
+    }) => Promise<void>;
+    get: () => Promise<string>;
+    getByAccountId: (props: {
+        accountId: string;
+    }) => Promise<string>;
+};
+export default balances;

package/dist/sdk/balances/index.js

@@ -0,0 +1,19 @@
+import { BalancesApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+const balances = (options) => {
+    const api = useAutogeneratedAPI({ API: BalancesApi, options });
+    return {
+        add: async (props) => api.call({
+            run: (methods) => methods.balancesControllerAddBalanceV1(props.accountId, { amount: props.amount }),
+        }),
+        get: async () => api.call({
+            run: (methods) => methods.balancesControllerGetBalanceForSelfV1(),
+            transform: (data) => data.balance,
+        }),
+        getByAccountId: async (props) => api.call({
+            run: (methods) => methods.balancesControllerGetBalanceV1(props.accountId),
+            transform: (data) => data.balance,
+        }),
+    };
+};
+export default balances;

package/dist/sdk/collections/index.d.ts

@@ -0,0 +1,33 @@
+import { SDKOptions, ListProps, ListResponse } from '../../types';
+import { CollectionEntity, CollectionsControllerListItemsV1KindEnum, ResourceEntity } from '../../autogenerated';
+import { CollectionMetadata } from '../index';
+import { AddMetadata } from '../utils';
+type CollectionEntityWithMetadata = AddMetadata<CollectionEntity, CollectionMetadata>;
+declare const collections: (options: SDKOptions) => {
+    create: (props?: {
+        metadata?: CollectionMetadata;
+    }) => Promise<CollectionEntityWithMetadata>;
+    get: (props: {
+        id: string;
+    }) => Promise<CollectionEntityWithMetadata | undefined>;
+    items: {
+        add: (props: {
+            collectionId: string;
+            itemIds: string[];
+        }) => Promise<void>;
+        list: (props: {
+            collectionId: string;
+            kind?: CollectionsControllerListItemsV1KindEnum;
+        } & ListProps) => Promise<ListResponse<ResourceEntity>>;
+        remove: (props: {
+            collectionId: string;
+            itemIds: string[];
+        }) => Promise<void>;
+    };
+    list: (props?: ListProps) => Promise<ListResponse<CollectionEntityWithMetadata>>;
+    updateMetadata: (props: {
+        id: string;
+        metadata?: Partial<CollectionMetadata>;
+    }) => Promise<void>;
+};
+export default collections;

package/dist/sdk/collections/index.js

@@ -0,0 +1,34 @@
+import { CollectionsApi, } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+import { transformToListResponse } from '../transformers';
+const collections = (options) => {
+    const api = useAutogeneratedAPI({ API: CollectionsApi, options });
+    return {
+        create: async (props = {}) => api.call({
+            run: (methods) => methods.collectionsControllerCreateCollectionV1({ metadata: props.metadata }),
+        }),
+        get: async (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.collectionsControllerGetCollectionV1(props.id),
+        }),
+        items: {
+            add: async (props) => api.call({
+                run: (methods) => methods.collectionsControllerAddItemsV1(props.collectionId, { itemIds: props.itemIds }),
+            }),
+            list: async (props) => api.call({
+                run: (methods) => methods.collectionsControllerListItemsV1(props.collectionId, props.cursor, props.orderBy, props.limit, props.kind),
+                transform: transformToListResponse,
+            }),
+            remove: async (props) => api.call({
+                run: (methods) => methods.collectionsControllerRemoveItemsV1(props.collectionId, { itemIds: props.itemIds }),
+            }),
+        },
+        list: (props = {}) => api.call({
+            run: (methods) => methods.collectionsControllerListCollectionsV1(props.orderBy, props.limit, props.cursor),
+            transform: transformToListResponse,
+        }),
+        updateMetadata: async (props) => api.call({
+            run: (methods) => methods.collectionsControllerUpdateMetadataV1(props.id, { overwrite: props.metadata ?? {} }),
+        }),
+    };
+};
+export default collections;

package/dist/sdk/errors/index.d.ts

@@ -0,0 +1,3 @@
+export declare class HautechError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}

package/dist/sdk/errors/index.js

@@ -0,0 +1,6 @@
+export class HautechError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'HautechException';
+    }
+}

package/dist/sdk/groups/index.d.ts

@@ -0,0 +1,24 @@
+import { SDKOptions } from '../../types';
+import { AddAccountToGroupControllerParamsDtoRoleEnum, GroupEntity, RemoveAccountFromGroupControllerParamsDtoRoleEnum } from '../../autogenerated';
+declare const groups: (options: SDKOptions) => {
+    accounts: {
+        add: (props: {
+            accountId: string;
+            groupId: string;
+            role: AddAccountToGroupControllerParamsDtoRoleEnum;
+        }) => Promise<void>;
+        remove: (props: {
+            accountId: string;
+            groupId: string;
+            role: RemoveAccountFromGroupControllerParamsDtoRoleEnum;
+        }) => Promise<void>;
+    };
+    create: () => Promise<GroupEntity>;
+    delete: (props: {
+        id: string;
+    }) => Promise<void>;
+    get: (props: {
+        id: string;
+    }) => Promise<GroupEntity | undefined>;
+};
+export default groups;

package/dist/sdk/groups/index.js

@@ -0,0 +1,31 @@
+import { GroupsApi, } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+const groups = (options) => {
+    const api = useAutogeneratedAPI({ API: GroupsApi, options });
+    return {
+        accounts: {
+            add: async (props) => api.call({
+                run: (methods) => methods.groupsControllerAddAccountV1(props.groupId, {
+                    accountId: props.accountId,
+                    role: props.role,
+                }),
+            }),
+            remove: async (props) => api.call({
+                run: (methods) => methods.groupsControllerRemoveAccountV1(props.groupId, {
+                    accountId: props.accountId,
+                    role: props.role,
+                }),
+            }),
+        },
+        create: async () => api.call({
+            run: (methods) => methods.groupsControllerCreateGroupV1(),
+        }),
+        delete: async (props) => api.call({
+            run: (methods) => methods.groupsControllerDeleteGroupV1(props.id),
+        }),
+        get: (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.groupsControllerGetGroupV1(props.id),
+        }),
+    };
+};
+export default groups;

package/dist/sdk/images/index.d.ts

@@ -0,0 +1,17 @@
+import { SDKOptions } from '../../types';
+import { ImageEntity } from '../../autogenerated';
+declare const images: (options: SDKOptions) => {
+    createFromFile: (props: {
+        file: Blob;
+    }) => Promise<ImageEntity>;
+    createFromUrl: (props: {
+        url: string;
+    }) => Promise<ImageEntity>;
+    get: (props: {
+        id: string;
+    }) => Promise<ImageEntity | undefined>;
+    getUrls: (props: {
+        ids: string[];
+    }) => Promise<Record<string, string>>;
+};
+export default images;

package/dist/sdk/images/index.js

@@ -0,0 +1,35 @@
+import axios from 'axios';
+import { ImagesApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+const images = (options) => {
+    const api = useAutogeneratedAPI({ API: ImagesApi, options });
+    const createFromFile = async (props) => {
+        const uploadUrl = await api.call({
+            run: (methods) => methods.imagesControllerStartUploadV1(),
+            transform: (data) => data.uploadUrl,
+        });
+        const formData = new FormData();
+        formData.append('file', props.file);
+        const response = await axios.put(uploadUrl, formData, {
+            headers: { 'Content-Type': 'multipart/form-data' },
+        });
+        const fileToken = response.data.fileToken;
+        return await api.call({ run: (methods) => methods.imagesControllerFinalizeUploadV1({ fileToken }) });
+    };
+    return {
+        createFromFile,
+        createFromUrl: async (props) => {
+            const response = await axios.get(props.url, { responseType: 'arraybuffer' });
+            const file = new Blob([response.data], { type: response.headers['content-type'] });
+            return createFromFile({ file });
+        },
+        get: async (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.imagesControllerGetImageV1(props.id),
+        }),
+        getUrls: async (props) => api.call({
+            run: (methods) => methods.imagesControllerGetUrlsV1({ ids: props.ids }),
+            transform: (data) => data.reduce((acc, { id, url }) => ({ ...acc, [id]: url }), {}),
+        }),
+    };
+};
+export default images;