@hautechai/sdk 0.0.1

package/dist/sdk/collections/index.js

@@ -0,0 +1,31 @@
+import { CollectionsApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+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),
+            }),
+            remove: async (props) => api.call({
+                run: (methods) => methods.collectionsControllerRemoveItemsV1(props.collectionId, { itemIds: props.itemIds }),
+            }),
+        },
+        list: async (props = {}) => api.call({
+            run: (methods) => methods.collectionsControllerListCollectionsV1(props.orderBy, props.limit, props.cursor),
+        }),
+        updateMetadata: async (props) => api.call({
+            run: (methods) => methods.collectionsControllerUpdateMetadataV1(props.id, { overwrite: props.metadata }),
+        }),
+    };
+};
+export default collections;

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

@@ -0,0 +1,24 @@
+import { SDKOptions } from '../../types';
+import { AddAccountToGroupControllerParamsDtoRoleEnum, 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<import("../../autogenerated").GroupEntity>;
+    delete: (props: {
+        id: string;
+    }) => Promise<void>;
+    get: (props: {
+        id: string;
+    }) => Promise<import("../../autogenerated").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,16 @@
+import { SDKOptions } from '../../types';
+declare const images: (options: SDKOptions) => {
+    createFromFile: (props: {
+        file: any;
+    }) => Promise<import("../../autogenerated").ImageEntity>;
+    createFromUrl: (props: {
+        url: string;
+    }) => Promise<import("../../autogenerated").ImageEntity>;
+    get: (props: {
+        id: string;
+    }) => Promise<import("../../autogenerated").ImageEntity | undefined>;
+    getUrls: (props: {
+        ids: string[];
+    }) => Promise<Record<string, string>>;
+};
+export default images;

package/dist/sdk/images/index.js

@@ -0,0 +1,36 @@
+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(props.file),
+            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;
+        const image = await api.call({ run: (methods) => methods.imagesControllerFinalizeUploadV1({ fileToken }) });
+        return image;
+    };
+    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;

package/dist/sdk/index.d.ts

@@ -0,0 +1,167 @@
+import { SDKOptions } from '../types';
+export declare const createSDK: (options: SDKOptions) => {
+    accounts: {
+        create: (props?: {
+            alias?: string;
+        }) => Promise<import("../autogenerated").AccountEntity>;
+        get: (props: {
+            id: string;
+        }) => Promise<import("../autogenerated").AccountEntity | undefined>;
+        getByAlias: (props: {
+            alias: string;
+        }) => Promise<import("../autogenerated").AccountEntity | undefined>;
+    };
+    balances: {
+        add: (props: {
+            accountId: string;
+            amount: string;
+        }) => Promise<void>;
+        get: () => Promise<string>;
+        getByAccountId: (props: {
+            accountId: string;
+        }) => Promise<string>;
+    };
+    collections: {
+        create: (props?: {
+            metadata?: any;
+        }) => Promise<import("../autogenerated").CollectionEntity>;
+        get: (props: {
+            id: string;
+        }) => Promise<import("../autogenerated").CollectionEntity | undefined>;
+        items: {
+            add: (props: {
+                collectionId: string;
+                itemIds: string[];
+            }) => Promise<void>;
+            list: (props: {
+                collectionId: string;
+            } & import("../types").ListProps) => Promise<import("../autogenerated").ListCollectionItemsDto>;
+            remove: (props: {
+                collectionId: string;
+                itemIds: string[];
+            }) => Promise<void>;
+        };
+        list: (props?: import("../types").ListProps) => Promise<import("../autogenerated").ListCollectionsDto>;
+        updateMetadata: (props: {
+            id: string;
+            metadata?: any;
+        }) => Promise<import("../autogenerated").ResourceEntity>;
+    };
+    groups: {
+        accounts: {
+            add: (props: {
+                accountId: string;
+                groupId: string;
+                role: import("../autogenerated").AddAccountToGroupControllerParamsDtoRoleEnum;
+            }) => Promise<void>;
+            remove: (props: {
+                accountId: string;
+                groupId: string;
+                role: import("../autogenerated").RemoveAccountFromGroupControllerParamsDtoRoleEnum;
+            }) => Promise<void>;
+        };
+        create: () => Promise<import("../autogenerated").GroupEntity>;
+        delete: (props: {
+            id: string;
+        }) => Promise<void>;
+        get: (props: {
+            id: string;
+        }) => Promise<import("../autogenerated").GroupEntity | undefined>;
+    };
+    images: {
+        createFromFile: (props: {
+            file: any;
+        }) => Promise<import("../autogenerated").ImageEntity>;
+        createFromUrl: (props: {
+            url: string;
+        }) => Promise<import("../autogenerated").ImageEntity>;
+        get: (props: {
+            id: string;
+        }) => Promise<import("../autogenerated").ImageEntity | undefined>;
+        getUrls: (props: {
+            ids: string[];
+        }) => Promise<Record<string, string>>;
+    };
+    operations: {
+        create: {
+            generate: {
+                v1: (props: {
+                    input: import("../autogenerated").GenerateV3Input;
+                    metadata?: any;
+                }) => Promise<import("../autogenerated").OperationEntity>;
+            };
+            inpaint: {
+                v1: (props: {
+                    input: import("../autogenerated").InpaintV1Input;
+                    metadata?: any;
+                }) => Promise<import("../autogenerated").OperationEntity>;
+            };
+        };
+        get: (props: {
+            id: string;
+        }) => Promise<import("../autogenerated").OperationEntity | undefined>;
+        getMany: (props: {
+            ids: string[];
+        }) => Promise<import("../autogenerated").OperationEntity[]>;
+        list: (props?: import("../types").ListProps) => Promise<import("../autogenerated").ListOperationsDto>;
+        updateMetadata: (props: {
+            id: string;
+            metadata?: any;
+        }) => Promise<import("../autogenerated").ResourceEntity>;
+        updates: {
+            subscribe: (props: {
+                callback: (operation: import("../autogenerated").OperationEntity) => void;
+            }) => void;
+            unsubscribe: (props: {
+                callback: (operation: import("../autogenerated").OperationEntity) => void;
+            }) => void;
+        };
+        wait: (props: {
+            id: string;
+            timeoutInSeconds?: number;
+        }) => Promise<unknown>;
+    };
+    stacks: {
+        create: (props?: {
+            metadata?: any;
+        }) => Promise<import("../autogenerated").StackEntity>;
+        get: (props: {
+            id: string;
+        }) => Promise<import("../autogenerated").StackEntity | undefined>;
+        list: (props?: import("../types").ListProps) => Promise<import("../autogenerated").ListStacksDto>;
+        operations: {
+            add: (props: {
+                operationIds: string[];
+                stackId: string;
+            }) => Promise<void>;
+            remove: (props: {
+                operationIds: string[];
+                stackId: string;
+            }) => Promise<import("../autogenerated").StackEntity>;
+        };
+        updateMetadata: (props: {
+            id: string;
+            metadata?: any;
+        }) => Promise<import("../autogenerated").ResourceEntity>;
+    };
+    storage: {
+        create: (props: {
+            key: string;
+            value: any;
+        }) => Promise<any>;
+        delete: (props: {
+            key: string;
+        }) => Promise<void>;
+        getMany: (props: {
+            keys: string[];
+        }) => Promise<Record<string, any>>;
+        update: (props: {
+            key: string;
+            value: any;
+        }) => Promise<any>;
+    };
+    utils: {
+        seed: () => number;
+    };
+};
+export type SDK = ReturnType<typeof createSDK>;

package/dist/sdk/index.js

@@ -0,0 +1,35 @@
+import accounts from './accounts';
+import balances from './balances';
+import collections from './collections';
+import groups from './groups';
+import images from './images';
+import jwt from 'jsonwebtoken';
+import operations from './operations';
+import stacks from './stacks';
+import storage from './storage';
+import utils from './utils';
+export const createSDK = (options) => {
+    let token = undefined;
+    const authToken = async () => {
+        if (token) {
+            const decoded = jwt.decode(token);
+            const currentTime = Math.floor(Date.now() / 1000);
+            if (decoded.exp && decoded.exp > currentTime)
+                return token;
+        }
+        token = await options.authToken();
+        return token;
+    };
+    const optionsWithTokenRefresher = { ...options, authToken };
+    return {
+        accounts: accounts(optionsWithTokenRefresher),
+        balances: balances(optionsWithTokenRefresher),
+        collections: collections(optionsWithTokenRefresher),
+        groups: groups(optionsWithTokenRefresher),
+        images: images(optionsWithTokenRefresher),
+        operations: operations(optionsWithTokenRefresher),
+        stacks: stacks(optionsWithTokenRefresher),
+        storage: storage(optionsWithTokenRefresher),
+        utils: utils(optionsWithTokenRefresher),
+    };
+};

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

@@ -0,0 +1,42 @@
+import { SDKOptions, ListProps } from '../../types';
+import { GenerateV3Input, InpaintV1Input } from '../../autogenerated';
+declare const operations: (options: SDKOptions) => {
+    create: {
+        generate: {
+            v1: (props: {
+                input: GenerateV3Input;
+                metadata?: any;
+            }) => Promise<import("../../autogenerated").OperationEntity>;
+        };
+        inpaint: {
+            v1: (props: {
+                input: InpaintV1Input;
+                metadata?: any;
+            }) => Promise<import("../../autogenerated").OperationEntity>;
+        };
+    };
+    get: (props: {
+        id: string;
+    }) => Promise<import("../../autogenerated").OperationEntity | undefined>;
+    getMany: (props: {
+        ids: string[];
+    }) => Promise<import("../../autogenerated").OperationEntity[]>;
+    list: (props?: ListProps) => Promise<import("../../autogenerated").ListOperationsDto>;
+    updateMetadata: (props: {
+        id: string;
+        metadata?: any;
+    }) => Promise<import("../../autogenerated").ResourceEntity>;
+    updates: {
+        subscribe: (props: {
+            callback: (operation: import("../../autogenerated").OperationEntity) => void;
+        }) => void;
+        unsubscribe: (props: {
+            callback: (operation: import("../../autogenerated").OperationEntity) => void;
+        }) => void;
+    };
+    wait: (props: {
+        id: string;
+        timeoutInSeconds?: number;
+    }) => Promise<unknown>;
+};
+export default operations;

package/dist/sdk/operations/index.js

@@ -0,0 +1,64 @@
+import createOperationUpdater from './updater';
+import { OperationsApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+const operations = (options) => {
+    const api = useAutogeneratedAPI({ API: OperationsApi, options });
+    const updates = createOperationUpdater(options);
+    return {
+        create: {
+            generate: {
+                v1: (props) => api.call({
+                    run: (methods) => methods.operationsControllerRunGenerateV3V1({
+                        input: props.input,
+                        metadata: props.metadata,
+                    }),
+                }),
+            },
+            inpaint: {
+                v1: (props) => api.call({
+                    run: (methods) => methods.operationsControllerRunInpaintV1V1({
+                        input: props.input,
+                        metadata: props.metadata,
+                    }),
+                }),
+            },
+        },
+        get: (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.operationsControllerGetOperationV1(props.id),
+        }),
+        getMany: (props) => api.call({
+            run: (methods) => methods.operationsControllerGetOperationsV1({ ids: props.ids }),
+        }),
+        list: (props = {}) => api.call({
+            run: (methods) => methods.operationsControllerListOperationsV1(props.orderBy, props.limit, props.cursor),
+        }),
+        updateMetadata: async (props) => api.call({
+            run: (methods) => methods.operationsControllerUpdateMetadataV1(props.id, { overwrite: props.metadata }),
+        }),
+        updates,
+        wait: async (props) => new Promise((resolve, reject) => {
+            const initialDelay = 5000;
+            const delay = 2000;
+            const listenToOperation = (operation) => {
+                if (operation.id === props.id) {
+                    clearTimeout(timeoutId);
+                    resolve(operation);
+                    updates.unsubscribe({ callback: listenToOperation });
+                }
+            };
+            updates.subscribe({ callback: listenToOperation });
+            let timeoutId;
+            const poll = async () => {
+                const operation = await api.call({
+                    run: (methods) => methods.operationsControllerGetOperationV1(props.id),
+                });
+                if (operation.status !== 'pending')
+                    return resolve(operation);
+                timeoutId = setTimeout(poll, delay);
+                updates.unsubscribe({ callback: listenToOperation });
+            };
+            timeoutId = setTimeout(poll, initialDelay);
+        }),
+    };
+};
+export default operations;

package/dist/sdk/operations/updater.d.ts

@@ -0,0 +1,11 @@
+import { SDKOptions } from '../../types';
+import { OperationEntity } from '../../autogenerated';
+declare const createOperationUpdater: (options: SDKOptions) => {
+    subscribe: (props: {
+        callback: (operation: OperationEntity) => void;
+    }) => void;
+    unsubscribe: (props: {
+        callback: (operation: OperationEntity) => void;
+    }) => void;
+};
+export default createOperationUpdater;

package/dist/sdk/operations/updater.js

@@ -0,0 +1,23 @@
+import { createWebsocket } from '../api';
+const createOperationUpdater = (options) => {
+    const eventListeners = [];
+    const eventListener = (operation) => {
+        eventListeners.forEach((listener) => listener(operation));
+    };
+    let websocketInited = false;
+    const initWebsocket = () => {
+        createWebsocket({ callback: eventListener, options, topic: 'operation' });
+        websocketInited = true;
+    };
+    return {
+        subscribe: (props) => {
+            eventListeners.push(props.callback);
+            if (!websocketInited)
+                initWebsocket();
+        },
+        unsubscribe: (props) => {
+            eventListeners.splice(eventListeners.indexOf(props.callback), 1);
+        },
+    };
+};
+export default createOperationUpdater;

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

@@ -0,0 +1,25 @@
+import { SDKOptions, ListProps } from '../../types';
+declare const stacks: (options: SDKOptions) => {
+    create: (props?: {
+        metadata?: any;
+    }) => Promise<import("../../autogenerated").StackEntity>;
+    get: (props: {
+        id: string;
+    }) => Promise<import("../../autogenerated").StackEntity | undefined>;
+    list: (props?: ListProps) => Promise<import("../../autogenerated").ListStacksDto>;
+    operations: {
+        add: (props: {
+            operationIds: string[];
+            stackId: string;
+        }) => Promise<void>;
+        remove: (props: {
+            operationIds: string[];
+            stackId: string;
+        }) => Promise<import("../../autogenerated").StackEntity>;
+    };
+    updateMetadata: (props: {
+        id: string;
+        metadata?: any;
+    }) => Promise<import("../../autogenerated").ResourceEntity>;
+};
+export default stacks;

package/dist/sdk/stacks/index.js

@@ -0,0 +1,30 @@
+import { StacksApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+const stacks = (options) => {
+    const api = useAutogeneratedAPI({ API: StacksApi, options });
+    return {
+        create: async (props = {}) => api.call({
+            run: (methods) => methods.stacksControllerCreateStackV1({
+                metadata: props.metadata,
+            }),
+        }),
+        get: async (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.stacksControllerGetStackV1(props.id),
+        }),
+        list: async (props = {}) => api.call({
+            run: (methods) => methods.stacksControllerListStacksV1(props.orderBy, props.limit, props.cursor),
+        }),
+        operations: {
+            add: async (props) => api.call({
+                run: (methods) => methods.stacksControllerAddOperationsV1(props.stackId, { operationIds: props.operationIds }),
+            }),
+            remove: async (props) => api.call({
+                run: (methods) => methods.stacksControllerRemoveOperationV1(props.stackId, { operationIds: props.operationIds }),
+            }),
+        },
+        updateMetadata: async (props) => api.call({
+            run: (methods) => methods.stacksControllerUpdateMetadataV1(props.id, { overwrite: props.metadata }),
+        }),
+    };
+};
+export default stacks;

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

@@ -0,0 +1,18 @@
+import { SDKOptions } from '../../types';
+declare const storage: (options: SDKOptions) => {
+    create: (props: {
+        key: string;
+        value: any;
+    }) => Promise<any>;
+    delete: (props: {
+        key: string;
+    }) => Promise<void>;
+    getMany: (props: {
+        keys: string[];
+    }) => Promise<Record<string, any>>;
+    update: (props: {
+        key: string;
+        value: any;
+    }) => Promise<any>;
+};
+export default storage;

package/dist/sdk/storage/index.js

@@ -0,0 +1,27 @@
+import { StorageApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+const storage = (options) => {
+    const api = useAutogeneratedAPI({ API: StorageApi, options });
+    return {
+        create: async (props) => api.call({
+            run: (methods) => methods.storageControllerCreateRecordV1({
+                key: props.key,
+                value: props.value,
+            }),
+        }),
+        delete: async (props) => api.call({
+            run: (methods) => methods.storageControllerDeleteRecordV1({ key: props.key }),
+        }),
+        getMany: async (props) => api.call({
+            run: (methods) => methods.storageControllerGetRecordsV1({ keys: props.keys }),
+            transform: (response) => response.reduce((acc, item) => {
+                acc[item.key] = item.value;
+                return acc;
+            }, {}),
+        }),
+        update: async (props) => api.call({
+            run: (methods) => methods.storageControllerUpdateRecordV1({ key: props.key, value: props.value }),
+        }),
+    };
+};
+export default storage;

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

@@ -0,0 +1,5 @@
+import { SDKOptions } from '../../types';
+declare const utils: (options: SDKOptions) => {
+    seed: () => number;
+};
+export default utils;

package/dist/sdk/utils/index.js

@@ -0,0 +1,6 @@
+const utils = (options) => {
+    return {
+        seed: () => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER),
+    };
+};
+export default utils;

package/dist/token/index.d.ts

@@ -0,0 +1,15 @@
+import { MethodsPermissions } from '../types';
+export declare const createTokenSigner: (options: {
+    appId: string;
+    appKeyId: string;
+    appKeySecret: string;
+}) => {
+    createAccountToken: (props: {
+        accountId: string;
+        expiresInSeconds: number;
+        permissions?: Partial<MethodsPermissions>;
+    }) => string;
+    createRootToken: (props: {
+        expiresInSeconds: number;
+    }) => string;
+};

package/dist/token/index.js

@@ -0,0 +1,38 @@
+import { defaultPermissions, defaultRootPermissions } from './permissions';
+import jwt from 'jsonwebtoken';
+const createPrivateKey = (key) => {
+    const header = `-----BEGIN PRIVATE KEY-----\n`;
+    const footer = `\n-----END PRIVATE KEY-----`;
+    // @ts-ignore
+    const keyBody = key.match(/.{1,64}/g).join('\n');
+    return header + keyBody + footer;
+};
+const createToken = (props) => {
+    const privateKey = createPrivateKey(props.appKeySecret);
+    return jwt.sign(props.payload, privateKey, {
+        algorithm: 'RS256',
+        expiresIn: props.expiresInSeconds,
+        keyid: props.appKeyId,
+    });
+};
+export const createTokenSigner = (options) => ({
+    createAccountToken: (props) => createToken({
+        appKeyId: options.appKeyId,
+        appKeySecret: options.appKeySecret,
+        expiresInSeconds: props.expiresInSeconds,
+        payload: {
+            iss: options.appId,
+            permissions: { ...defaultPermissions, ...(props.permissions ?? {}) },
+            sub: props.accountId,
+        },
+    }),
+    createRootToken: (props) => createToken({
+        appKeyId: options.appKeyId,
+        appKeySecret: options.appKeySecret,
+        expiresInSeconds: props.expiresInSeconds ?? 3600,
+        payload: {
+            iss: options.appId,
+            permissions: defaultRootPermissions,
+        },
+    }),
+});

package/dist/token/permissions.d.ts

@@ -0,0 +1,3 @@
+import { MethodsPermissions } from '../types';
+export declare const defaultPermissions: MethodsPermissions;
+export declare const defaultRootPermissions: MethodsPermissions;