epicenter-libs 3.34.2 → 3.35.0

package/dist/types/epicenter.d.ts

@@ -1,11 +1,11 @@
 import 'regenerator-runtime/runtime';
-declare const version = "Epicenter (v__VERSION__) for __BUILD__ | Build Date: __DATE__";
+declare const version: string;
 import { Handler } from './utils/error-manager';
 export declare const DEFAULT_ERROR_HANDLERS: Record<string, Handler>;
 export * from './types';
 export { version };
 export { SCOPE_BOUNDARY, RITUAL, PUSH_CATEGORY, ROLE, } from './utils/constants';
 export { config, errorManager, Router, Fault, } from './utils';
-export { accountAdapter, adminAdapter, assetAdapter, consensusAdapter, emailAdapter, authAdapter, chatAdapter, episodeAdapter, groupAdapter, leaderboardAdapter, presenceAdapter, projectAdapter, recaptchaAdapter, runAdapter, taskAdapter, timeAdapter, userAdapter, vaultAdapter, videoAdapter, vonageAdapter, worldAdapter, somebodyAdapter, dailyAdapter, matchmakerAdapter, walletAdapter, Channel, cometdAdapter, } from './adapters';
+export { accountAdapter, adminAdapter, assetAdapter, consensusAdapter, emailAdapter, authAdapter, chatAdapter, episodeAdapter, groupAdapter, leaderboardAdapter, presenceAdapter, projectAdapter, recaptchaAdapter, runAdapter, taskAdapter, timeAdapter, userAdapter, vaultAdapter, videoAdapter, vonageAdapter, worldAdapter, somebodyAdapter, dailyAdapter, matchmakerAdapter, walletAdapter, pipelineAdapter, encyclopediaAdapter, fileAdapter, registrationAdapter, docketAdapter, Channel, cometdAdapter, gitAdapter, powerpointAdapter, } from './adapters';
 export { videoAPI, vonageAPI, } from './apis';
 export * as utils from './utilities';

package/dist/types/types.d.ts

@@ -24,10 +24,15 @@ export type { Leaderboard, Score, Tag, } from './adapters/leaderboard';
 export type { Presence, } from './adapters/presence';
 export type { ACCESS_TYPE, AccessType, WORKER_PARTITION, WorkerPartition, PHYLOGENY, Phylogeny, FileType, CHANNEL_PROTOCOL, ChannelProtocol, ProjectMember, Deployment, TeamProject, PersonalProject, Project, } from './adapters/project';
 export type { RunReadOutView, RunVariables, RunMetadata, RunCreateOptions, RunStrategy, ExecutionContext, ModelContext, ModelContextDefaults, OperationOptions, VariableOptions, EventOptions, RewindMarker, ReplayOperation, ReplayRestoration, SnapshotRestoration, Restorations, Protections, InputGuard, OverwriteGuard, RelativeGuard, RoleGuard, PrivilegeGuard, V1ExecutionContext, V2ModelContext, ExcelModelControl, JavaModelControl, PowersimModelControl, VensimModelControl, VensimModelTool, StellaModelTool, ProcActionable, GetActionable, SetActionable, Actionable, Route, WireExternalFunction, AptExternalDependency, CranExternalDependency, GitExternalDependency, JuliaExternalDependency, NpmExternalDependency, PypiExternalDependency, ShellExternalDependency, MORPHOLOGY, MetadataFirstPop, MetadataLastPop, MetadataAllPop, MetadataPop, MetadataUpdate, } from './adapters/run';
-export type { RETRY_POLICY, TaskPayloadBody, TaskPayloadHeaders, StatusReadOutView, StatusCreateInView, CronTaskTriggerCreateInView, DateTaskTriggerCreateInView, OffsetTaskTriggerCreateInView, TaskTriggerCreateInView, HttpTaskPayloadCreateInView, GroupStatusTaskPayloadCreateInView, TaskPayloadCreateInView, HttpTaskPayloadReadOutView, GroupStatusTaskPayloadReadOutView, TaskPayloadReadOutView, TaskReadOutView, } from './adapters/task';
+export type { RETRY_POLICY, TaskPayloadBody, TaskPayloadHeaders, TaskHttpMethod, TaskRetryPolicyReadOutView, TaskStatusReadOutView, TaskAddressReadOutView, TaskScopeReadOutView, StatusReadOutView, StatusCreateInView, CronTaskTriggerCreateInView, DateTaskTriggerCreateInView, OffsetTaskTriggerCreateInView, TaskTriggerCreateInView, HttpTaskPayloadCreateInView, GroupStatusTaskPayloadCreateInView, TaskPayloadCreateInView, HttpTaskPayloadCreateInput, TaskPayloadCreateInput, HttpTaskPayloadReadOutView, GroupStatusTaskPayloadReadOutView, TaskPayloadReadOutView, TaskReadOutView, TaskHistoryReadOutView, TaskPageOptions, TaskScopePageOptions, } from './adapters/task';
 export type { UserReadOutView, UserCreateInView, NativeUserCreateInView, ExternalUserCreateInView, ExternalUserReadOutView, NativeUserReadOutView, PseudonymReadOutView, UserReport, DiscardedUser, MFADetailReadOutView, MFADetailCreateInView, GraftReadOutView, GraftCreateInView, SecretCreateInView, GroupRelationshipReadOutView, UploadOptions, Modality, MFAMethodology, Countdown, RealmData, } from './adapters/user';
 export type { Vault, VaultItems, Items, } from './adapters/vault';
 export type { WalletReadOutView, WalletItemReadOutView, WalletItemCreateInView, } from './adapters/wallet';
 export type { WorldReadOutView, WorldRole, AssignmentReadOutView, AssignmentCreateInView, PersonaReadOutView, PersonaCreateInView, AssignmentMap, ColorAnimalWorldNameGenerator, SequentialWorldNameGenerator, WorldNameGenerator, WORLD_NAME_GENERATOR_TYPE, WorldNameGeneratorType, OBJECTIVE, Objective, OrbitType, } from './adapters/world';
+export type { FileEntry, DirectoryEntry, FileSystemEntry, } from './adapters/file';
+export type { RegistrationInfo, TeamRegistrationInfo, RegistrationResult, WhoAmI, WhoAmIObjectType, TeamRole, SsoProtocol, } from './adapters/registration';
+export type { OperatingSystem, WorkerShape, ScaleFlavor, ScaleCreateInView, ScaleReadOutView, ScaleDocketPayloadCreateInView, ScaleDocketPayloadReadOutView, DocketPayloadCreateInView, DocketPayloadReadOutView, DocketReadOutView, } from './adapters/docket';
+export type { EncyclopediaTranslator, DocumentedEndpointMethod, DocumentedEndpointAuthorization, DocumentedEndpointNotation, DocumentedParameterSource, DocumentedParameter, DocumentedEndpoint, DocumentedResource, KnownServiceReadOutView, } from './adapters/encyclopedia';
+export type { PipelineExecutionStatus, PipelineAuditReadOutView, } from './adapters/pipeline';
 export type { Somebody, } from './adapters/somebody';
 export type { VideoReadOutView, VideoDir, AFFILIATE, Affiliate, MEDIA_FORMAT, MediaFormat, LANGUAGE_CODE, LanguageCode, ProcessingType, } from './apis/video';

package/dist/types/utils/router.d.ts

@@ -34,6 +34,7 @@ export interface RetryFunction<Output> {
 export interface Page<Item> {
     firstResult: number;
     maxResults: number;
+    resultSize: number;
     totalResults: number;
     values: Item[];
     prev: () => Promise<Item[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "epicenter-libs",
-  "version": "3.34.2",
+  "version": "3.35.0",
   "main": "dist/cjs/epicenter.js",
   "type": "module",
   "module": "dist/module/epicenter.js",
@@ -13,8 +13,9 @@
   ],
   "scripts": {
     "test": "vitest",
-    "test:run": "vitest run",
-    "test:coverage": "vitest run --coverage",
+    "test:run": "npm run type-check && vitest run",
+    "test:coverage": "npm run type-check && vitest run --coverage",
+    "test:dist": "npm run build && vitest run --config vitest.dist.config.js",
     "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
     "changelog:all": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
     "type-check": "tsc --noEmit",
@@ -23,9 +24,7 @@
     "build:types": "tsc --emitDeclarationOnly",
     "build:js": "rollup -c -m",
     "build": "npm run build:clean && npm run build:types && npm run build:js",
-    "build:test": "rollup -c rollup.config.test.js",
-    "pretest": "npm run type-check && npm run build:test",
-    "pretest:run": "npm run type-check && npm run build:test",
+    "prepublishOnly": "npm run test:run && npm run test:dist",
     "start": "rollup -c -m inline -w",
     "prepare": "node -e \"if (!process.env.CI && !process.env.JENKINS_HOME) require('child_process').execSync('husky', {stdio: 'inherit'})\""
   },
@@ -50,6 +49,11 @@
     "cometd": "^8.0.9",
     "cross-fetch": "^3.0.6"
   },
+  "overrides": {
+    "tar": "^7.5.16",
+    "esbuild": "^0.28.1",
+    "sigstore": "^4.1.1"
+  },
   "devDependencies": {
     "@babel/cli": "^7.26.0",
     "@babel/core": "^7.26.0",
@@ -70,9 +74,10 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-replace": "^6.0.2",
-    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-terser": "^1.0.0",
     "@stylistic/eslint-plugin": "^5.4.0",
     "@types/cometd": "^4.0.8",
+    "@vitest/coverage-v8": "^3.2.6",
     "babel-loader": "^9.2.1",
     "conventional-changelog": "^7.1.1",
     "conventional-changelog-angular": "^8.0.0",

package/src/adapters/docket.ts

@@ -0,0 +1,109 @@
+import type { RoutingOptions } from '../utils/router';
+import type { TaskTriggerCreateInView } from './task';
+
+import { Router } from '../utils';
+
+export type OperatingSystem = 'LINUX' | 'MAC' | 'WINDOWS';
+
+export type WorkerShape =
+    | 'GS' | 'GM' | 'GL' | 'GXL' | 'G2XL' | 'G4XL'
+    | 'ML' | 'MXL' | 'M2XL' | 'M4XL'
+    | 'CL' | 'CXL' | 'C2XL' | 'C4XL';
+
+export type ScaleFlavor = 'PROCESS' | 'DOCKER' | 'JVM' | 'WSDL';
+
+export interface ScaleCreateInView {
+    active: boolean;
+    initialWorkerCount: number;
+    additionalWorkerLimit: number;
+    flavors?: ScaleFlavor[];
+}
+
+export interface ScaleReadOutView {
+    active?: boolean | null;
+    initialWorkerCount?: number | null;
+    additionalWorkerLimit?: number | null;
+    flavors?: ScaleFlavor[] | null;
+    test?: boolean | null;
+    shape?: WorkerShape | null;
+    operatingSystem?: OperatingSystem | null;
+}
+
+export interface ScaleDocketPayloadCreateInView {
+    objectType: 'scale';
+    scale: ScaleCreateInView;
+    operatingSystem: OperatingSystem;
+    workerShape: WorkerShape;
+    test?: boolean;
+}
+
+export interface ScaleDocketPayloadReadOutView {
+    objectType: 'scale';
+    scale?: ScaleReadOutView | null;
+    operatingSystem?: OperatingSystem | null;
+    workerShape?: WorkerShape | null;
+    test?: boolean | null;
+}
+
+export type DocketPayloadCreateInView = ScaleDocketPayloadCreateInView;
+export type DocketPayloadReadOutView = ScaleDocketPayloadReadOutView;
+
+export interface DocketReadOutView {
+    docketKey?: string | null;
+    date?: string | null;
+    payload?: DocketPayloadReadOutView | null;
+    ttlMinutes?: number | null;
+    complete?: boolean | null;
+    error?: string | null;
+    attempts?: number | null;
+}
+
+
+/**
+ * Creates a new docket entry, scheduling a deferred operation for later execution.
+ * Requires `support` level authorization.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/docket`
+ *
+ * @example
+ * import { docketAdapter } from 'epicenter-libs';
+ * const docket = await docketAdapter.create(
+ *     {
+ *         objectType: 'scale',
+ *         operatingSystem: 'LINUX',
+ *         workerShape: 'GS',
+ *         scale: {
+ *             active: true,
+ *             initialWorkerCount: 1,
+ *             additionalWorkerLimit: 4,
+ *             flavors: ['DOCKER'],
+ *         },
+ *     },
+ *     { objectType: 'date', value: '2026-06-01T00:00:00Z' },
+ *     '2026-05-20T00:00:00Z',
+ *     { ttlMinutes: 60 },
+ * );
+ *
+ * @param payload                   Docket payload describing the operation to schedule
+ * @param trigger                   Trigger describing when the operation should fire
+ *                                  (cron, date, or offset)
+ * @param date                      ISO-8601 date string indicating when the docket is scheduled
+ * @param [optionals]               Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.ttlMinutes]    Time-to-live in minutes for the docket entry (minimum 2)
+ * @returns promise that resolves to the newly created docket
+ */
+export async function create(
+    payload: DocketPayloadCreateInView,
+    trigger: TaskTriggerCreateInView,
+    date: string,
+    optionals: {
+        ttlMinutes?: number;
+    } & RoutingOptions = {},
+): Promise<DocketReadOutView> {
+    const { ttlMinutes, ...routingOptions } = optionals;
+    return await new Router()
+        .post('/docket', {
+            body: { payload, trigger, date, ttlMinutes },
+            ...routingOptions,
+        })
+        .then(({ body }) => body);
+}

package/src/adapters/encyclopedia.ts

@@ -0,0 +1,128 @@
+import type { RoutingOptions } from '../utils/router';
+
+import { Router } from '../utils';
+
+
+export type EncyclopediaTranslator = 'ASCIIDOC' | 'ASCIIDOC_TO_HTML' | 'OPENAPI';
+
+export type DocumentedEndpointMethod = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+
+export type DocumentedEndpointAuthorization = 'SYSTEM' | 'DASHBOARD' | 'OWNER' | 'AUTHOR' | 'SUPPORT' | 'REVIEWER' | 'FACILITATOR' | 'LEADER' | 'PARTICIPANT' | 'ANONYMOUS';
+
+export type DocumentedEndpointNotation = 'POST_RATHER_THAN_GET' | 'UNSUPPORTED_IGNORED';
+
+export type DocumentedParameterSource = 'PATH' | 'HEADER' | 'QUERY' | 'MATRIX';
+
+export interface DocumentedParameter {
+    name?: string;
+    source?: DocumentedParameterSource;
+    type?: Record<string, unknown>;
+}
+
+export interface DocumentedEndpoint {
+    method?: DocumentedEndpointMethod;
+    path?: string;
+    authorization?: DocumentedEndpointAuthorization;
+    response?: Record<string, unknown>;
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    paged?: boolean;
+    notations?: DocumentedEndpointNotation[];
+    body?: Record<string, unknown>;
+    parameters?: DocumentedParameter[];
+    produces?: unknown[];
+    consumes?: unknown[];
+}
+
+export interface DocumentedResource {
+    silenced?: boolean;
+    endpoints?: DocumentedEndpoint[];
+    definitions?: Record<string, unknown>;
+}
+
+export interface KnownServiceReadOutView {
+    name?: string;
+    development?: boolean;
+    trusted?: boolean;
+    published?: boolean;
+}
+
+
+/**
+ * Lists the known API services available for the given encyclopedia version.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/encyclopedia/v{version}`
+ *
+ * @example
+ * import { encyclopediaAdapter } from 'epicenter-libs';
+ * const services = await encyclopediaAdapter.listServices(3);
+ *
+ * @param version       Encyclopedia version number
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to an array of known service descriptors
+ */
+export async function listServices(
+    version: number,
+    optionals: RoutingOptions = {},
+): Promise<KnownServiceReadOutView[]> {
+    return await new Router()
+        .get(`/encyclopedia/v${version}`, optionals)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Retrieves the documented resource (API documentation) for a specific service and encyclopedia version.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/encyclopedia/v{version}/{api}`
+ *
+ * @example
+ * import { encyclopediaAdapter } from 'epicenter-libs';
+ * const resource = await encyclopediaAdapter.getResource(3, 'run');
+ *
+ * @param version       Encyclopedia version number
+ * @param api           Name of the API service to retrieve documentation for
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the documented resource containing endpoints and definitions
+ */
+export async function getResource(
+    version: number,
+    api: string,
+    optionals: RoutingOptions = {},
+): Promise<DocumentedResource> {
+    return await new Router()
+        .get(`/encyclopedia/v${version}/${api}`, optionals)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Retrieves a translated representation of the API documentation for a specific service and encyclopedia version.
+ * Supported translators are ASCIIDOC, ASCIIDOC_TO_HTML, and OPENAPI.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/encyclopedia/as/{translator}/v{version}/{api}`
+ *
+ * NOTE: The backend returns the translated content with a translator-specific content-type
+ * (e.g. `text/asciidoc`, `text/html`, `application/json`). The shared Router throws when the
+ * response content-type is not `application/json`, so only the OPENAPI translator works here.
+ * For ASCIIDOC and ASCIIDOC_TO_HTML, use the underlying fetch API directly against the
+ * constructed URL.
+ *
+ * @example
+ * import { encyclopediaAdapter } from 'epicenter-libs';
+ * const openApiDoc = await encyclopediaAdapter.translate('OPENAPI', 3, 'run');
+ *
+ * @param translator    Output format for the documentation; one of 'ASCIIDOC', 'ASCIIDOC_TO_HTML', or 'OPENAPI'
+ * @param version       Encyclopedia version number
+ * @param api           Name of the API service to translate documentation for
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the translated documentation (only when translator is 'OPENAPI')
+ */
+export async function translate(
+    translator: EncyclopediaTranslator,
+    version: number,
+    api: string,
+    optionals: RoutingOptions = {},
+): Promise<unknown> {
+    return await new Router()
+        .get(`/encyclopedia/as/${translator}/v${version}/${api}`, optionals)
+        .then(({ body }) => body);
+}

package/src/adapters/file.ts

@@ -0,0 +1,332 @@
+import type { RoutingOptions } from '../utils/router';
+
+import { Router } from '../utils';
+
+
+export interface FileEntry {
+    objectType: 'file';
+    name?: string;
+    lastModifiedTime?: string;
+    size?: number;
+    contentType?: string;
+}
+
+export interface DirectoryEntry {
+    objectType: 'directory';
+    name?: string;
+    lastModifiedTime?: string;
+    children?: FileSystemEntry[];
+}
+
+export type FileSystemEntry = FileEntry | DirectoryEntry;
+
+
+/* File paths are free-form, user-authored strings that may contain spaces or URL-reserved
+ * characters. Encode each segment while preserving the '/' separators that the backend's
+ * `{filePath:.*}` routes expect. */
+const encodePath = (filePath: string): string =>
+    filePath.split('/').map(encodeURIComponent).join('/');
+
+
+/**
+ * Lists files and directories at the project root or at a specific path.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file[/{filePath}]`
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * // List all files at root
+ * const entries = await fileAdapter.list();
+ * // List contents of a specific directory up to 2 levels deep
+ * const entries = await fileAdapter.list('src', { depth: 2 });
+ *
+ * @param [filePath]        Path to a file or directory; omit to list the project root
+ * @param [optionals]       Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.depth] Maximum depth of directory traversal to include in the response
+ * @returns promise that resolves to an array of file and directory entries
+ */
+export async function list(
+    filePath?: string,
+    optionals: {
+        depth?: number;
+    } & RoutingOptions = {},
+): Promise<FileSystemEntry[]> {
+    const { depth, ...routingOptions } = optionals;
+    const uriComponent = filePath ? `/${encodePath(filePath)}` : '';
+    return await new Router()
+        .withSearchParams({ depth })
+        .get(`/file${uriComponent}`, routingOptions)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Uploads and replaces files at the project root or at a specific path using multipart/form-data (PUT).
+ * Use this when you want to overwrite existing files. For creating new files, use `create`.
+ * Base URL: PUT `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file[/{filePath}]`
+ *
+ * NOTE: This is browser-only. The `FormData` body is only serialized as multipart/form-data when
+ * running in a browser environment; in Node it will not be sent correctly.
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * const formData = new FormData();
+ * formData.append('file', myFile);
+ * const uploaded = await fileAdapter.upload(formData, 'models/model.py');
+ *
+ * @param formData          Multipart form data containing the file(s) to upload
+ * @param [filePath]        Destination path for the file(s); omit to upload to the project root
+ * @param [optionals]       Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to an array of the uploaded file entries
+ */
+export async function upload(
+    formData: FormData,
+    filePath?: string,
+    optionals: RoutingOptions = {},
+): Promise<FileEntry[]> {
+    const uriComponent = filePath ? `/${encodePath(filePath)}` : '';
+    return await new Router()
+        .put(`/file${uriComponent}`, {
+            body: formData,
+            ...optionals,
+        }).then(({ body }) => body);
+}
+
+
+/**
+ * Creates new files at the project root or at a specific path using multipart/form-data (POST).
+ * Use this when creating new files. For overwriting existing files, use `upload`.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file[/{filePath}]`
+ *
+ * NOTE: This is browser-only. The `FormData` body is only serialized as multipart/form-data when
+ * running in a browser environment; in Node it will not be sent correctly.
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * const formData = new FormData();
+ * formData.append('file', myFile);
+ * const created = await fileAdapter.create(formData, 'models/model.py');
+ *
+ * @param formData          Multipart form data containing the file(s) to create
+ * @param [filePath]        Destination path for the file(s); omit to create at the project root
+ * @param [optionals]       Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to an array of the created file entries
+ */
+export async function create(
+    formData: FormData,
+    filePath?: string,
+    optionals: RoutingOptions = {},
+): Promise<FileEntry[]> {
+    const uriComponent = filePath ? `/${encodePath(filePath)}` : '';
+    return await new Router()
+        .post(`/file${uriComponent}`, {
+            body: formData,
+            ...optionals,
+        }).then(({ body }) => body);
+}
+
+
+/**
+ * Deletes a file or directory at the project root or at a specific path.
+ * Base URL: DELETE `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file[/{filePath}]`
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * // Delete a specific file
+ * await fileAdapter.remove('models/old-model.py');
+ * // Delete all files at the project root
+ * await fileAdapter.remove();
+ *
+ * @param [filePath]    Path of the file or directory to delete; omit to delete all files at the project root
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves when the deletion is complete
+ */
+export async function remove(
+    filePath?: string,
+    optionals: RoutingOptions = {},
+): Promise<void> {
+    const uriComponent = filePath ? `/${encodePath(filePath)}` : '';
+    return await new Router()
+        .delete(`/file${uriComponent}`, optionals)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Downloads the raw content of a file at the specified path.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file/download/{filePath}`
+ *
+ * NOTE: The backend streams the file with its detected content type (e.g. `application/zip`,
+ * `text/plain`, `application/octet-stream`). The shared Router throws when the response
+ * content-type is not `application/json`, so this call only succeeds for JSON files. To download
+ * other file types, use the underlying fetch API directly against the constructed URL.
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * const content = await fileAdapter.download('config.json');
+ *
+ * @param filePath          Path to the file to download
+ * @param [optionals]       Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.depth] Currently unused on the backend; reserved for future expansion.
+ * @returns promise that resolves to the raw file content
+ */
+export async function download(
+    filePath: string,
+    optionals: {
+        depth?: number;
+    } & RoutingOptions = {},
+): Promise<unknown> {
+    const { depth, ...routingOptions } = optionals;
+    return await new Router()
+        .withSearchParams({ depth })
+        .get(`/file/download/${encodePath(filePath)}`, routingOptions)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Lists files and directories matching a glob filter pattern, optionally scoped to a specific path.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file/filter/{filter}[/{filePath}]`
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * // List all Python files in the project
+ * const pyFiles = await fileAdapter.listByFilter('*.py');
+ * // List all Python files within the 'models' directory
+ * const pyFiles = await fileAdapter.listByFilter('*.py', 'models');
+ *
+ * @param filter            Glob pattern to filter files by (e.g., '*.py', '*.json')
+ * @param [filePath]        Directory path to scope the filter to; omit to search the entire project
+ * @param [optionals]       Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.depth] Maximum depth of directory traversal to include in the response
+ * @returns promise that resolves to an array of matching file and directory entries
+ */
+export async function listByFilter(
+    filter: string,
+    filePath?: string,
+    optionals: {
+        depth?: number;
+    } & RoutingOptions = {},
+): Promise<FileSystemEntry[]> {
+    const { depth, ...routingOptions } = optionals;
+    const uriComponent = filePath ? `/${encodePath(filePath)}` : '';
+    return await new Router()
+        .withSearchParams({ depth })
+        .get(`/file/filter/${encodeURIComponent(filter)}${uriComponent}`, routingOptions)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Compresses files into a ZIP archive at the project root or at a specific path.
+ * Base URL: PATCH `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file/compress[/{filePath}]`
+ *
+ * NOTE: The backend streams the resulting archive with content-type `application/zip`. The
+ * shared Router throws when the response content-type is not `application/json`, so this call
+ * will not return the archive bytes through the normal flow. To retrieve the archive, use the
+ * underlying fetch API directly against the constructed URL.
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * // Compress a specific file or directory
+ * await fileAdapter.compress('models');
+ * // Compress at root
+ * await fileAdapter.compress();
+ *
+ * @param [filePath]    Path of the file or directory to compress; omit to compress at the project root
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the compression result
+ */
+export async function compress(
+    filePath?: string,
+    optionals: RoutingOptions = {},
+): Promise<unknown> {
+    const uriComponent = filePath ? `/${encodePath(filePath)}` : '';
+    return await new Router()
+        .patch(`/file/compress${uriComponent}`, optionals)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Extracts (explodes) a ZIP archive at the project root or at a specific path in place,
+ * deleting the archive after extraction.
+ * Base URL: PATCH `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file/explode[/{filePath}]`
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * // Extract a specific archive
+ * await fileAdapter.explode('archive.zip');
+ * // Explode at root
+ * await fileAdapter.explode();
+ *
+ * @param [filePath]    Path of the archive to extract; omit to extract at the project root
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves when the extraction is complete
+ */
+export async function explode(
+    filePath?: string,
+    optionals: RoutingOptions = {},
+): Promise<void> {
+    const uriComponent = filePath ? `/${encodePath(filePath)}` : '';
+    return await new Router()
+        .patch(`/file/explode${uriComponent}`, optionals)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Moves a file or directory from one path to another within the project.
+ * Base URL: PATCH `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file/move`
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * await fileAdapter.move('models/old-name.py', 'models/new-name.py');
+ * // Move and include the origin directory itself
+ * await fileAdapter.move('old-dir', 'new-dir', { includeOrigin: true });
+ *
+ * @param origin                Origin path of the file or directory to move
+ * @param destination           Destination path to move the file or directory to
+ * @param [optionals]           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.includeOrigin] Whether to include the origin directory itself in the move
+ * @returns promise that resolves when the move is complete
+ */
+export async function move(
+    origin: string,
+    destination: string,
+    optionals: {
+        includeOrigin?: boolean;
+    } & RoutingOptions = {},
+): Promise<void> {
+    const { includeOrigin, ...routingOptions } = optionals;
+    return await new Router()
+        .patch('/file/move', {
+            body: {
+                origin,
+                destination,
+                includeOrigin,
+            },
+            ...routingOptions,
+        }).then(({ body }) => body);
+}
+
+
+/**
+ * Creates a new directory at the specified path.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/file/directory/{filePath}`
+ *
+ * @example
+ * import { fileAdapter } from 'epicenter-libs';
+ * const dir = await fileAdapter.createDirectory('models/new-folder');
+ *
+ * @param filePath      Path at which to create the new directory
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the created directory entry
+ */
+export async function createDirectory(
+    filePath: string,
+    optionals: RoutingOptions = {},
+): Promise<DirectoryEntry> {
+    return await new Router()
+        .post(`/file/directory/${encodePath(filePath)}`, optionals)
+        .then(({ body }) => body);
+}