@autonomys/auto-drive 1.0.3 → 1.0.5

package/dist/api/models/folderTree.js

@@ -0,0 +1,103 @@
+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());
+    });
+};
+import fs from 'fs';
+import JSZip from 'jszip';
+import { z } from 'zod';
+export const FolderTreeFolderSchema = z.object({
+    name: z.string(),
+    type: z.literal('folder'),
+    children: z.array(z.lazy(() => FolderTreeSchema)),
+    id: z.string(),
+});
+export const FolderTreeFileSchema = z.object({
+    name: z.string(),
+    type: z.literal('file'),
+    id: z.string(),
+});
+export const FolderTreeSchema = z.discriminatedUnion('type', [
+    FolderTreeFolderSchema,
+    FolderTreeFileSchema,
+]);
+export const constructFromFileSystemEntries = (entries) => {
+    const root = {
+        name: 'root',
+        type: 'folder',
+        children: [],
+        id: 'root',
+    };
+    for (const entry of entries) {
+        const pathParts = entry.split('/').filter(Boolean);
+        let currentFolder = root;
+        for (const [index, part] of Array.from(pathParts.entries())) {
+            // Check if the part already exists in the current folder's children
+            let existingFolder = currentFolder.children.find((child) => child.name === part);
+            if (!existingFolder) {
+                // If it's the last part, create a file node
+                if (index === pathParts.length - 1) {
+                    const fileNode = {
+                        name: part,
+                        type: 'file',
+                        id: entry,
+                    };
+                    currentFolder.children.push(fileNode);
+                }
+                else {
+                    // Create a new folder node
+                    const folderNode = {
+                        name: part,
+                        type: 'folder',
+                        children: [],
+                        id: `${currentFolder.id.split('/').slice(1).join('/')}/${part}`,
+                    };
+                    currentFolder.children.push(folderNode);
+                    existingFolder = folderNode;
+                }
+            }
+            currentFolder = existingFolder; // Move to the next folder
+        }
+    }
+    return root.children.length === 1 ? root.children[0] : root;
+};
+export const constructFromInput = (input) => {
+    return constructFromFileSystemEntries(Array.from(input).map((file) => {
+        if (!file.webkitRelativePath) {
+            throw new Error('webkitRelativePath is not supported');
+        }
+        return file.webkitRelativePath;
+    }));
+};
+const addFilesToZip = (folder, folderNode, files) => {
+    folderNode.children.forEach((child) => {
+        if (child.type === 'file') {
+            const file = files[child.id];
+            if (typeof file === 'string') {
+                folder.file(child.name, fs.createReadStream(file));
+            }
+            else {
+                folder.file(child.name, file);
+            }
+        }
+        else if (child.type === 'folder') {
+            const subFolder = folder.folder(child.name);
+            if (!subFolder) {
+                throw new Error('Failed to create folder in zip');
+            }
+            addFilesToZip(subFolder, child, files);
+        }
+    });
+};
+export const constructZipBlobFromTreeAndPaths = (tree, files) => __awaiter(void 0, void 0, void 0, function* () {
+    if (tree.type === 'file') {
+        throw new Error('Cannot construct zip from file');
+    }
+    const zip = new JSZip();
+    addFilesToZip(zip, tree, files);
+    return zip.generateAsync({ type: 'blob' });
+});

package/dist/{esm/api → api}/models/index.d.ts

@@ -1,2 +1,3 @@
 export * from './objects.js';
 export * from './uploads.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/models/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA"}

package/dist/{cjs/api → api}/models/objects.d.ts

@@ -38,3 +38,4 @@ export interface ObjectInformation {
     uploadStatus: ObjectUploadStatus;
     owners: Owner[];
 }
+//# sourceMappingURL=objects.d.ts.map

package/dist/api/models/objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../../src/api/models/objects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAE3D,oBAAY,KAAK;IACf,MAAM,WAAW;IACjB,IAAI,SAAS;CACd;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,SAAS,CAAA;CAChB;AAED,oBAAY,SAAS;IACnB,KAAK,UAAU;IACf,MAAM,WAAW;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;CACjC;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,YAAY,EAAE,kBAAkB,CAAA;CACjC,GAAG,CACA;IACE,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,CAAC,gBAAgB,GAAG;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC,UAAU,CAAC,CAAA;CAC9D,CACJ,CAAA;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,YAAY,EAAE,kBAAkB,CAAA;IAChC,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB"}

package/dist/api/models/objects.js

@@ -0,0 +1,10 @@
+export var Scope;
+(function (Scope) {
+    Scope["Global"] = "global";
+    Scope["User"] = "user";
+})(Scope || (Scope = {}));
+export var OwnerRole;
+(function (OwnerRole) {
+    OwnerRole["ADMIN"] = "admin";
+    OwnerRole["VIEWER"] = "viewer";
+})(OwnerRole || (OwnerRole = {}));

package/dist/api/models/uploads.d.ts

@@ -0,0 +1,130 @@
+import { CID, FileUploadOptions } from '@autonomys/auto-dag-data';
+import { z } from 'zod';
+export declare enum UploadType {
+    FILE = "file",
+    FOLDER = "folder"
+}
+export declare enum UploadStatus {
+    PENDING = "pending",
+    COMPLETED = "completed",
+    MIGRATING = "migrating",
+    CANCELLED = "cancelled",
+    FAILED = "failed"
+}
+export declare const fileUploadSchema: z.ZodObject<{
+    id: z.ZodString;
+    rootId: z.ZodString;
+    relativeId: z.ZodNullable<z.ZodString>;
+    type: z.ZodNativeEnum<typeof UploadType>;
+    status: z.ZodNativeEnum<typeof UploadStatus>;
+    fileTree: z.ZodNull;
+    name: z.ZodString;
+    mimeType: z.ZodNullable<z.ZodString>;
+    oauthProvider: z.ZodString;
+    oauthUserId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: UploadType;
+    status: UploadStatus;
+    id: string;
+    rootId: string;
+    relativeId: string | null;
+    fileTree: null;
+    mimeType: string | null;
+    oauthProvider: string;
+    oauthUserId: string;
+}, {
+    name: string;
+    type: UploadType;
+    status: UploadStatus;
+    id: string;
+    rootId: string;
+    relativeId: string | null;
+    fileTree: null;
+    mimeType: string | null;
+    oauthProvider: string;
+    oauthUserId: string;
+}>;
+export type FileUpload = z.infer<typeof fileUploadSchema> & {
+    uploadOptions: FileUploadOptions | null;
+};
+export declare const folderUploadSchema: z.ZodObject<{
+    id: z.ZodString;
+    rootId: z.ZodString;
+    relativeId: z.ZodNullable<z.ZodString>;
+    type: z.ZodNativeEnum<typeof UploadType>;
+    status: z.ZodNativeEnum<typeof UploadStatus>;
+    fileTree: z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"folder">;
+        children: z.ZodArray<z.ZodLazy<z.ZodType<import("./folderTree.js").FolderTree, z.ZodTypeDef, import("./folderTree.js").FolderTree>>, "many">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        children: import("./folderTree.js").FolderTree[];
+        name: string;
+        type: "folder";
+        id: string;
+    }, {
+        children: import("./folderTree.js").FolderTree[];
+        name: string;
+        type: "folder";
+        id: string;
+    }>;
+    name: z.ZodString;
+    mimeType: z.ZodNull;
+    oauthProvider: z.ZodString;
+    oauthUserId: z.ZodString;
+    uploadOptions: z.ZodNull;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: UploadType;
+    status: UploadStatus;
+    id: string;
+    rootId: string;
+    relativeId: string | null;
+    fileTree: {
+        children: import("./folderTree.js").FolderTree[];
+        name: string;
+        type: "folder";
+        id: string;
+    };
+    mimeType: null;
+    oauthProvider: string;
+    oauthUserId: string;
+    uploadOptions: null;
+}, {
+    name: string;
+    type: UploadType;
+    status: UploadStatus;
+    id: string;
+    rootId: string;
+    relativeId: string | null;
+    fileTree: {
+        children: import("./folderTree.js").FolderTree[];
+        name: string;
+        type: "folder";
+        id: string;
+    };
+    mimeType: null;
+    oauthProvider: string;
+    oauthUserId: string;
+    uploadOptions: null;
+}>;
+export type FolderUpload = z.infer<typeof folderUploadSchema>;
+export type CompleteUploadResponse = {
+    cid: string;
+};
+export type UploadFileStatus = {
+    type: 'file';
+    progress: number;
+    cid?: CID;
+};
+export type UploadFolderStatus = {
+    type: 'folder';
+    progress: number;
+    cid?: CID;
+};
+export type UploadChunksStatus = {
+    uploadBytes: number;
+};
+//# sourceMappingURL=uploads.d.ts.map

package/dist/api/models/uploads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.d.ts","sourceRoot":"","sources":["../../../src/api/models/uploads.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,oBAAY,UAAU;IACpB,IAAI,SAAS;IACb,MAAM,WAAW;CAClB;AAED,oBAAY,YAAY;IACtB,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,MAAM,WAAW;CAClB;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW3B,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,GAAG;IAC1D,aAAa,EAAE,iBAAiB,GAAG,IAAI,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,CAAC,EAAE,GAAG,CAAA;CACV,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,CAAC,EAAE,GAAG,CAAA;CACV,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA"}

package/dist/api/models/uploads.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { FolderTreeFolderSchema } from './folderTree.js';
+export var UploadType;
+(function (UploadType) {
+    UploadType["FILE"] = "file";
+    UploadType["FOLDER"] = "folder";
+})(UploadType || (UploadType = {}));
+export var UploadStatus;
+(function (UploadStatus) {
+    UploadStatus["PENDING"] = "pending";
+    UploadStatus["COMPLETED"] = "completed";
+    UploadStatus["MIGRATING"] = "migrating";
+    UploadStatus["CANCELLED"] = "cancelled";
+    UploadStatus["FAILED"] = "failed";
+})(UploadStatus || (UploadStatus = {}));
+export const fileUploadSchema = z.object({
+    id: z.string(),
+    rootId: z.string(),
+    relativeId: z.string().nullable(),
+    type: z.nativeEnum(UploadType),
+    status: z.nativeEnum(UploadStatus),
+    fileTree: z.null(),
+    name: z.string(),
+    mimeType: z.string().nullable(),
+    oauthProvider: z.string(),
+    oauthUserId: z.string(),
+});
+export const folderUploadSchema = z.object({
+    id: z.string(),
+    rootId: z.string(),
+    relativeId: z.string().nullable(),
+    type: z.nativeEnum(UploadType),
+    status: z.nativeEnum(UploadStatus),
+    fileTree: FolderTreeFolderSchema,
+    name: z.string(),
+    mimeType: z.null(),
+    oauthProvider: z.string(),
+    oauthUserId: z.string(),
+    uploadOptions: z.null(),
+});

package/dist/api/wrappers.d.ts

@@ -0,0 +1,107 @@
+import { PromisedObservable } from '../utils/observable.js';
+import { AutoDriveApi } from './connection.js';
+import { GenericFile } from './models/file.js';
+import { UploadChunksStatus, UploadFileStatus, UploadFolderStatus } from './models/uploads.js';
+type UploadFileOptions = {
+    password?: string;
+    compression?: boolean;
+};
+/**
+ * Uploads a file to the server with optional encryption and compression.
+ *
+ * This function reads a file from the specified file path, optionally encrypts it
+ * using the provided password, and compresses it using the specified algorithm if requested.
+ * It then uploads the file in chunks to the server, creating an upload session and
+ * completing it once all chunks have been successfully uploaded.
+ *
+ * @param {AutoDriveApi} api - The API instance used to send requests.
+ * @param {string} filePath - The path to the file to be uploaded.
+ * @param {UploadFileOptions} options - Options for the upload process.
+ * @param {string} [options.password] - The password for encryption (optional).
+ * @param {boolean} [options.compression=true] - Whether to compress the file (optional).
+ * @param {number} [uploadChunkSize] - The size of each chunk to upload (optional).
+ * @returns {PromisedObservable<UploadFileStatus>} - An observable that emits the upload status.
+ * @throws {Error} - Throws an error if the upload fails at any stage.
+ */
+export declare const uploadFileFromFilepath: (api: AutoDriveApi, filePath: string, { password, compression }: UploadFileOptions, uploadChunkSize?: number) => PromisedObservable<UploadFileStatus>;
+/**
+ * Uploads a file to the server with optional encryption and compression.
+ *
+ * This function reads a file from the provided input, optionally encrypts it
+ * using the specified password, and compresses it using the specified algorithm if requested.
+ * It uploads the file in chunks to the server, creating an upload session and
+ * completing it once all chunks have been successfully uploaded.
+ *
+ * @param {AutoDriveApi} api - The API instance used to send requests.
+ * @param {File | GenericFile} file - The file to be uploaded, which can be a File or a GenericFile.
+ * @param {UploadFileOptions} options - Options for the upload process.
+ * @param {string} [options.password] - The password for encryption (optional).
+ * @param {boolean} [options.compression=true] - Whether to compress the file (optional).
+ * @param {number} [uploadChunkSize] - The size of each chunk to upload (optional).
+ * @returns {Promise<CID>} - A promise that resolves with the CID of the uploaded file.
+ * @throws {Error} - Throws an error if the upload fails at any stage.
+ */
+export declare const uploadFileFromInput: (api: AutoDriveApi, file: File | GenericFile, { password, compression }: UploadFileOptions, uploadChunkSize?: number) => PromisedObservable<UploadFileStatus>;
+/**
+ * Uploads an entire folder to the server.
+ *
+ * This function retrieves all files within the specified folder,
+ * constructs a file tree representation, and initiates the upload
+ * process. It also handles optional compression and encryption of the files during
+ * the upload.
+ *
+ * If a password is provided, the files will be zipped before uploading.
+ *
+ * @param {AutoDriveApi} api - The API instance used to send requests.
+ * @param {string} folderPath - The path of the folder to be uploaded.
+ * @param {Object} options - Optional parameters for the upload.
+ * @param {number} [options.uploadChunkSize] - The size of each chunk to be uploaded.
+ * @param {string} [options.password] - An optional password for encrypting the files.
+ * @returns {Promise<PromisedObservable<UploadFileStatus | UploadFolderStatus>>} - A promise that resolves to an observable that tracks the upload progress.
+ * @throws {Error} - Throws an error if the upload fails at any stage.
+ */
+export declare const uploadFolderFromFolderPath: (api: AutoDriveApi, folderPath: string, { uploadChunkSize, password }?: {
+    uploadChunkSize?: number;
+    password?: string;
+}) => Promise<PromisedObservable<UploadFileStatus | UploadFolderStatus>>;
+/**
+ * Uploads an entire folder to the server.
+ *
+ * This function retrieves all files within the specified folder,
+ * constructs a file tree representation, and initiates the upload
+ * process. It also handles optional compression of the files during
+ * the upload. If a password is provided, the files will be zipped
+ * before uploading.
+ *
+ * @param {AutoDriveApi} api - The API instance used to send requests.
+ * @param {FileList | File[]} fileList - The list of files to be uploaded.
+ * @param {Object} options - Options for the upload process.
+ * @param {number} [options.uploadChunkSize] - The size of each chunk to upload (optional).
+ * @param {string} [options.password] - The password for encryption (optional).
+ * @returns {PromisedObservable<UploadFileStatus | UploadFolderStatus>} - An observable that emits the upload status.
+ * @throws {Error} - Throws an error if the upload fails at any stage.
+ */
+export declare const uploadFolderFromInput: (api: AutoDriveApi, fileList: FileList | File[], { uploadChunkSize, password }?: {
+    uploadChunkSize?: number;
+    password?: string;
+}) => Promise<PromisedObservable<UploadFileStatus | UploadFolderStatus>>;
+/**
+ * Uploads a file within an existing folder upload session.
+ *
+ * @param {AutoDriveApi} api - The API instance to interact with the AutoDrive service.
+ * @param {string} uploadId - The ID of the folder upload session to which the file will be added.
+ * @param {string} filepath - The path of the file to be uploaded.
+ *
+ * @returns {Promise<void>} A promise that resolves when the file upload is complete.
+ */
+export declare const uploadFileWithinFolderUpload: (api: AutoDriveApi, uploadId: string, file: GenericFile, uploadChunkSize?: number) => PromisedObservable<UploadChunksStatus>;
+/**
+ * Downloads a file from the AutoDrive service.
+ *
+ * @param {AutoDriveApi} api - The API instance to interact with the AutoDrive service.
+ * @param {string} cid - The CID of the file to be downloaded.
+ * @returns {Promise<ReadableStream<Uint8Array>>} A promise that resolves to a ReadableStream of the downloaded file.
+ */
+export declare const downloadFile: (api: AutoDriveApi, cid: string, password?: string) => Promise<AsyncIterable<Buffer>>;
+export {};
+//# sourceMappingURL=wrappers.d.ts.map

package/dist/api/wrappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrappers.d.ts","sourceRoot":"","sources":["../../src/api/wrappers.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAU3D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAM9C,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAE9F,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAuBD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB,QAC5B,YAAY,YACP,MAAM,6BACkB,iBAAiB,oBACjC,MAAM,KACvB,kBAAkB,CAAC,gBAAgB,CAkBrC,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,QACzB,YAAY,QACX,IAAI,GAAG,WAAW,6BACU,iBAAiB,oBACjC,MAAM,KACvB,kBAAkB,CAAC,gBAAgB,CA8CrC,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,0BAA0B,QAChC,YAAY,cACL,MAAM,kCACa;IAAE,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,KAC7E,OAAO,CAAC,kBAAkB,CAAC,gBAAgB,GAAG,kBAAkB,CAAC,CA6DnE,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,qBAAqB,QAC3B,YAAY,YACP,QAAQ,GAAG,IAAI,EAAE,kCACI;IAAE,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,KAC7E,OAAO,CAAC,kBAAkB,CAAC,gBAAgB,GAAG,kBAAkB,CAAC,CA+DnE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,QAClC,YAAY,YACP,MAAM,QACV,WAAW,oBACC,MAAM,KACvB,kBAAkB,CAAC,kBAAkB,CAkBvC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,QAClB,YAAY,OACZ,MAAM,aACA,MAAM,KAChB,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAoB/B,CAAA"}