epicenter-libs 3.34.2 → 3.35.1

package/dist/types/adapters/docket.d.ts

@@ -0,0 +1,80 @@
+import type { RoutingOptions } from '../utils/router';
+import type { TaskTriggerCreateInView } from './task';
+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 declare function create(payload: DocketPayloadCreateInView, trigger: TaskTriggerCreateInView, date: string, optionals?: {
+    ttlMinutes?: number;
+} & RoutingOptions): Promise<DocketReadOutView>;

package/dist/types/adapters/encyclopedia.d.ts

@@ -0,0 +1,86 @@
+import type { RoutingOptions } from '../utils/router';
+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 declare function listServices(version: number, optionals?: RoutingOptions): Promise<KnownServiceReadOutView[]>;
+/**
+ * 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 declare function getResource(version: number, api: string, optionals?: RoutingOptions): Promise<DocumentedResource>;
+/**
+ * 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 declare function translate(translator: EncyclopediaTranslator, version: number, api: string, optionals?: RoutingOptions): Promise<unknown>;

package/dist/types/adapters/file.d.ts

@@ -0,0 +1,201 @@
+import type { RoutingOptions } from '../utils/router';
+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;
+/**
+ * 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 declare function list(filePath?: string, optionals?: {
+    depth?: number;
+} & RoutingOptions): Promise<FileSystemEntry[]>;
+/**
+ * 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 declare function upload(formData: FormData, filePath?: string, optionals?: RoutingOptions): Promise<FileEntry[]>;
+/**
+ * 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 declare function create(formData: FormData, filePath?: string, optionals?: RoutingOptions): Promise<FileEntry[]>;
+/**
+ * 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 declare function remove(filePath?: string, optionals?: RoutingOptions): Promise<void>;
+/**
+ * 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 declare function download(filePath: string, optionals?: {
+    depth?: number;
+} & RoutingOptions): Promise<unknown>;
+/**
+ * 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 declare function listByFilter(filter: string, filePath?: string, optionals?: {
+    depth?: number;
+} & RoutingOptions): Promise<FileSystemEntry[]>;
+/**
+ * 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 declare function compress(filePath?: string, optionals?: RoutingOptions): Promise<unknown>;
+/**
+ * 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 declare function explode(filePath?: string, optionals?: RoutingOptions): Promise<void>;
+/**
+ * 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 declare function move(origin: string, destination: string, optionals?: {
+    includeOrigin?: boolean;
+} & RoutingOptions): Promise<void>;
+/**
+ * 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 declare function createDirectory(filePath: string, optionals?: RoutingOptions): Promise<DirectoryEntry>;

package/dist/types/adapters/git.d.ts

@@ -0,0 +1,171 @@
+import type { RoutingOptions } from '../utils/router';
+export type GitAlgorithm = 'rsa' | 'ed25519';
+export type GitKeySpec = 'openssh' | 'pkcs8' | 'x509';
+export interface GitStatusReadOutView {
+    currentBranch?: string | null;
+}
+export interface GitIntegrationReadOutView {
+    privateKeySpec?: GitKeySpec | null;
+    publicKey?: string | null;
+    uri?: string | null;
+    publicKeySpec?: GitKeySpec | null;
+    algorithm?: GitAlgorithm | null;
+}
+export interface GitIntegrationCreateInView {
+    privateKey: string;
+    privateKeySpec: GitKeySpec;
+    publicKey: string;
+    uri: string;
+    publicKeySpec: GitKeySpec;
+    algorithm: GitAlgorithm;
+}
+export interface GitIntegrationUpdateInView {
+    privateKey?: string | null;
+    privateKeySpec: GitKeySpec;
+    publicKey?: string | null;
+    uri?: string | null;
+    publicKeySpec: GitKeySpec;
+    algorithm: GitAlgorithm;
+}
+/**
+ * Retrieves the git integration configuration for the project.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/git`
+ *
+ * @example
+ * import { gitAdapter } from 'epicenter-libs';
+ * const integration = await gitAdapter.get();
+ *
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the git integration configuration
+ */
+export declare function get(optionals?: RoutingOptions): Promise<GitIntegrationReadOutView>;
+/**
+ * Retrieves the current git status for the project.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/git/status`
+ *
+ * @example
+ * import { gitAdapter } from 'epicenter-libs';
+ * const status = await gitAdapter.getStatus();
+ * console.log(status.currentBranch);
+ *
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the git status, including the current branch
+ */
+export declare function getStatus(optionals?: RoutingOptions): Promise<GitStatusReadOutView>;
+/**
+ * Checks out a branch in the project's git repository.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/git/checkout/{branch}`
+ *
+ * @example
+ * import { gitAdapter } from 'epicenter-libs';
+ * await gitAdapter.checkout('main');
+ *
+ * @param branch        Name of the branch to check out
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves when the checkout is complete
+ */
+export declare function checkout(branch: string, optionals?: RoutingOptions): Promise<void>;
+/**
+ * Resets the project's git repository, optionally to a specific branch.
+ * Base URL: DELETE `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/git/reset[/{branch}]`
+ *
+ * @example
+ * import { gitAdapter } from 'epicenter-libs';
+ * await gitAdapter.reset();                        // reset current branch
+ * await gitAdapter.reset({ branch: 'main' });      // reset to 'main'
+ *
+ * @param [optionals]           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.branch]    Branch to reset to; if omitted, resets the current branch
+ * @returns promise that resolves when the reset is complete
+ */
+export declare function reset(optionals?: {
+    branch?: string;
+} & RoutingOptions): Promise<void>;
+/**
+ * Creates a git integration for the project.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/git/integration`
+ *
+ * @example
+ * import { gitAdapter } from 'epicenter-libs';
+ * const integration = await gitAdapter.createIntegration({
+ *     uri: 'git@github.com:myorg/myrepo.git',
+ *     publicKey: '...',
+ *     privateKey: '...',
+ *     publicKeySpec: 'openssh',
+ *     privateKeySpec: 'pkcs8',
+ *     algorithm: 'ed25519',
+ * });
+ *
+ * @param integration   Git integration configuration to create
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the created git integration
+ */
+export declare function createIntegration(integration: GitIntegrationCreateInView, optionals?: RoutingOptions): Promise<GitIntegrationReadOutView>;
+/**
+ * Updates the git integration for the project.
+ * Base URL: PATCH `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/git/integration`
+ *
+ * @example
+ * import { gitAdapter } from 'epicenter-libs';
+ * const integration = await gitAdapter.updateIntegration({
+ *     uri: 'git@github.com:myorg/newrepo.git',
+ *     publicKeySpec: 'openssh',
+ *     privateKeySpec: 'pkcs8',
+ *     algorithm: 'ed25519',
+ * });
+ *
+ * @param integration   Fields to update on the git integration
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the updated git integration
+ */
+export declare function updateIntegration(integration: GitIntegrationUpdateInView, optionals?: RoutingOptions): Promise<GitIntegrationReadOutView>;
+/**
+ * Removes the git integration for the project.
+ * Base URL: DELETE `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/git/integration`
+ *
+ * @example
+ * import { gitAdapter } from 'epicenter-libs';
+ * await gitAdapter.removeIntegration();
+ *
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves when the integration is removed
+ */
+export declare function removeIntegration(optionals?: RoutingOptions): Promise<void>;
+/**
+ * Pushes local commits to the remote git repository.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/git/push`
+ *
+ * @example
+ * import { gitAdapter } from 'epicenter-libs';
+ * await gitAdapter.push({ message: 'Update simulation data' });
+ *
+ * @param optionals             Arguments object; also accepts network call option overrides.
+ * @param optionals.message     Commit message (required)
+ * @param [optionals.password]  Password for authentication
+ * @param [optionals.force]     Force-push, bypassing non-fast-forward checks
+ * @returns promise that resolves when the push is complete
+ */
+export declare function push(optionals: {
+    message: string;
+    password?: string | null;
+    force?: boolean | null;
+} & RoutingOptions): Promise<void>;
+/**
+ * Pulls changes from the remote git repository into the project.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/git/pull`
+ *
+ * @example
+ * import { gitAdapter } from 'epicenter-libs';
+ * await gitAdapter.pull({ force: true, confirm: true });
+ *
+ * @param [optionals]           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.password]  Password for authentication
+ * @param [optionals.force]     Force the pull, overwriting local changes
+ * @param [optionals.confirm]   Set the `X-Forio-Confirmation` header to confirm an overwrite
+ * @returns promise that resolves when the pull is complete
+ */
+export declare function pull(optionals?: {
+    password?: string | null;
+    force?: boolean | null;
+    confirm?: boolean | null;
+} & RoutingOptions): Promise<void>;

package/dist/types/adapters/index.d.ts

@@ -23,6 +23,13 @@ import * as somebodyAdapter from './somebody';
 import * as matchmakerAdapter from './matchmaker';
 import * as dailyAdapter from './daily';
 import * as walletAdapter from './wallet';
+import * as pipelineAdapter from './pipeline';
+import * as encyclopediaAdapter from './encyclopedia';
+import * as fileAdapter from './file';
+import * as registrationAdapter from './registration';
+import * as docketAdapter from './docket';
 import { default as cometdAdapter } from './cometd';
 import { default as Channel } from './channel';
-export { accountAdapter, adminAdapter, authAdapter, assetAdapter, chatAdapter, cometdAdapter, emailAdapter, episodeAdapter, groupAdapter, leaderboardAdapter, presenceAdapter, projectAdapter, recaptchaAdapter, runAdapter, timeAdapter, userAdapter, vaultAdapter, videoAdapter, vonageAdapter, worldAdapter, taskAdapter, consensusAdapter, somebodyAdapter, matchmakerAdapter, dailyAdapter, walletAdapter, Channel, };
+import * as gitAdapter from './git';
+import * as powerpointAdapter from './powerpoint';
+export { accountAdapter, adminAdapter, authAdapter, assetAdapter, chatAdapter, cometdAdapter, emailAdapter, episodeAdapter, groupAdapter, leaderboardAdapter, presenceAdapter, projectAdapter, recaptchaAdapter, runAdapter, timeAdapter, userAdapter, vaultAdapter, videoAdapter, vonageAdapter, worldAdapter, taskAdapter, consensusAdapter, somebodyAdapter, matchmakerAdapter, dailyAdapter, walletAdapter, pipelineAdapter, encyclopediaAdapter, fileAdapter, registrationAdapter, docketAdapter, Channel, gitAdapter, powerpointAdapter, };

package/dist/types/adapters/pipeline.d.ts

@@ -0,0 +1,88 @@
+import type { Page, RoutingOptions } from '../utils/router';
+export type PipelineExecutionStatus = 'RUNNING' | 'SUCCEEDED' | 'FAILED';
+export interface PipelineAuditReadOutView {
+    status?: PipelineExecutionStatus | null;
+    started?: string | null;
+    finished?: string | null;
+    executionKey?: string | null;
+    accountShortName?: string | null;
+    projectShortName?: string | null;
+    configName?: string | null;
+    creator?: string | null;
+}
+/**
+ * Builds the NPM Docker images used by pipeline NPM operations.
+ * Requires `system` (admin) authorization.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/pipeline/npm/images`
+ *
+ * @example
+ * import { pipelineAdapter } from 'epicenter-libs';
+ * const built = await pipelineAdapter.buildImages();
+ *
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to `true` when the images were built successfully
+ */
+export declare function buildImages(optionals?: RoutingOptions): Promise<boolean>;
+/**
+ * Executes a stored pipeline configuration. The operations to run are read server-side from the
+ * named config file; only step inputs (such as credentials) are supplied here via `attributes`.
+ * The execution runs asynchronously — the returned audit record starts in its `RUNNING` state and
+ * is updated by the worker on completion (poll `getExecution` to observe progress).
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/pipeline/{configName}`
+ *
+ * @example
+ * import { pipelineAdapter } from 'epicenter-libs';
+ * // Pass the git credential the config's git step will consume, keyed by operation type
+ * const audit = await pipelineAdapter.execute('deploy', { git: 'my-git-token' });
+ *
+ * @param configName        Name of the stored pipeline config to execute
+ * @param [attributes]      Step inputs keyed by operation type (e.g. `{ git: '<token>' }`)
+ * @param [optionals]       Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the newly created audit record in its initial RUNNING state
+ */
+export declare function execute(configName: string, attributes?: Record<string, unknown>, optionals?: RoutingOptions): Promise<PipelineAuditReadOutView>;
+/**
+ * Retrieves a single pipeline audit record by its execution key.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/pipeline/{executionKey}`
+ *
+ * @example
+ * import { pipelineAdapter } from 'epicenter-libs';
+ * const audit = await pipelineAdapter.getExecution('<executionKey>');
+ *
+ * @param executionKey  Execution key of the audit record to retrieve
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the audit record
+ */
+export declare function getExecution(executionKey: string, optionals?: RoutingOptions): Promise<PipelineAuditReadOutView>;
+/**
+ * Lists the audit history for a stored pipeline config.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/pipeline/with/{configName}`
+ *
+ * @example
+ * import { pipelineAdapter } from 'epicenter-libs';
+ * const page = await pipelineAdapter.listAudits('deploy', { first: 0, max: 20 });
+ *
+ * @param configName        Name of the stored pipeline config
+ * @param [optionals]       Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.first] Index of the first record to return (for pagination)
+ * @param [optionals.max]   Maximum number of records to return (for pagination)
+ * @returns promise that resolves to a page of audit records
+ */
+export declare function listAudits(configName: string, optionals?: {
+    first?: number;
+    max?: number;
+} & RoutingOptions): Promise<Page<PipelineAuditReadOutView>>;
+/**
+ * Deletes a pipeline audit record by its execution key.
+ * Requires `system` (admin) authorization.
+ * Base URL: DELETE `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/pipeline/{executionKey}`
+ *
+ * @example
+ * import { pipelineAdapter } from 'epicenter-libs';
+ * await pipelineAdapter.deleteAudit('<executionKey>');
+ *
+ * @param executionKey  Execution key of the audit record to delete
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to `true` when the audit record was deleted
+ */
+export declare function deleteAudit(executionKey: string, optionals?: RoutingOptions): Promise<boolean>;