epicenter-libs 3.34.2 → 3.35.1

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

@@ -0,0 +1,130 @@
+import type { RoutingOptions } from '../utils/router';
+export type TemplateDirectory = 'DATA' | 'MODEL';
+export interface NDataPoint {
+    n?: number | null;
+}
+export interface XYDataPoint {
+    x?: number | null;
+    y?: number | null;
+}
+export interface BarSeriesShadow {
+    objectType: 'bar';
+    name?: string;
+    data?: NDataPoint[] | null;
+}
+export interface AreaSeriesShadow {
+    objectType: 'area';
+    name?: string;
+    data?: NDataPoint[] | null;
+}
+export interface LineSeriesShadow {
+    objectType: 'line';
+    name?: string;
+    data?: NDataPoint[] | null;
+}
+export interface PieSeriesShadow {
+    objectType: 'pie';
+    name?: string;
+    data?: NDataPoint[] | null;
+}
+export interface ScatterSeriesShadow {
+    objectType: 'scatter';
+    name?: string;
+    data?: XYDataPoint[] | null;
+}
+export interface YSeriesShadow {
+    objectType: 'y';
+    name?: string;
+    data?: number[] | null;
+}
+export interface XYSeriesShadow {
+    objectType: 'xy';
+    name?: string;
+    data?: XYDataPoint[] | null;
+}
+export type SeriesShadow = BarSeriesShadow | AreaSeriesShadow | LineSeriesShadow | PieSeriesShadow | ScatterSeriesShadow | YSeriesShadow | XYSeriesShadow;
+export interface ChartShadow {
+    name?: string;
+    categories?: unknown[] | null;
+    series?: SeriesShadow[] | null;
+}
+export interface TableShadow {
+    name?: string;
+    header?: unknown;
+    data?: unknown[] | null;
+}
+export interface PictureShadow {
+    name?: string;
+    data?: BinaryData;
+}
+export interface BinaryData {
+    encoding: 'HEX' | 'BASE_64';
+    data: unknown;
+    encryption?: 'AES' | null;
+    name?: string | null;
+    content_type?: string | null;
+    contentType?: unknown;
+}
+export interface EnvironmentShadow {
+    parameters?: Record<string, unknown> | null;
+    charts?: ChartShadow[] | null;
+    tables?: TableShadow[] | null;
+    pictures?: PictureShadow[] | null;
+}
+export interface SlideShadow {
+    /** Slide number (1-based) */
+    number?: number;
+    environment?: EnvironmentShadow;
+}
+export interface DocumentShadow {
+    output?: string;
+    environment?: EnvironmentShadow;
+    slides?: SlideShadow[] | null;
+}
+/**
+ * Generates a PowerPoint file from a template and returns it as binary data (JSON-encoded)
+ * Base URL: PUT `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/powerpoint/{TEMPLATE_DIRECTORY}/{TEMPLATE_PATH}`
+ *
+ * @example
+ * import { powerpointAdapter } from 'epicenter-libs';
+ * const binaryData = await powerpointAdapter.generate('MODEL', 'en-US-debrief-template.pptx', {
+ *     output: 'debrief-slides.pptx',
+ *     environment: {},
+ *     slides: [
+ *         {
+ *             number: 1,
+ *             environment: {
+ *                 tables: [{ name: 'Leaderboard', data: [['Rank', 'Name', 'Score']] }],
+ *             },
+ *         },
+ *     ],
+ * });
+ *
+ * @param templateDirectory     Directory where the template is stored: 'DATA' or 'MODEL'
+ * @param templatePath          Path to the template file within the directory
+ * @param document              Document shadow defining the output filename, environment, and slides
+ * @param [optionals]           Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the generated PowerPoint as BinaryData
+ */
+export declare function generate(templateDirectory: TemplateDirectory, templatePath: string, document: DocumentShadow, optionals?: RoutingOptions): Promise<BinaryData>;
+/**
+ * Generates a PowerPoint file from a template and returns it as a streaming response.
+ * Useful for downloading the generated file directly.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/powerpoint/{TEMPLATE_DIRECTORY}/{TEMPLATE_PATH}`
+ *
+ * @example
+ * import { powerpointAdapter } from 'epicenter-libs';
+ * const response = await powerpointAdapter.stream('MODEL', 'en-US-debrief-template.pptx', {
+ *     output: 'debrief-slides.pptx',
+ *     environment: {},
+ *     slides: [],
+ * });
+ * const blob = await response.blob();
+ *
+ * @param templateDirectory     Directory where the template is stored: 'DATA' or 'MODEL'
+ * @param templatePath          Path to the template file within the directory
+ * @param document              Document shadow defining the output filename, environment, and slides
+ * @param [optionals]           Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the raw Response for streaming/blob handling
+ */
+export declare function stream(templateDirectory: TemplateDirectory, templatePath: string, document: DocumentShadow, optionals?: RoutingOptions): Promise<Response>;

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

@@ -0,0 +1,270 @@
+import type { RoutingOptions } from '../utils/router';
+export interface RegistrationInfo {
+    projectShortName?: string | null;
+    groupName?: string | null;
+    accountShortName?: string | null;
+    accountName?: string | null;
+    familyName?: string | null;
+    givenName?: string | null;
+    projectName?: string | null;
+    email?: string | null;
+    groupKey?: string | null;
+}
+export interface TeamRegistrationInfo {
+    accountShortName?: string | null;
+    accountName?: string | null;
+    familyName?: string | null;
+    givenName?: string | null;
+    email?: string | null;
+}
+export type WhoAmIObjectType = 'system' | 'dashboard' | 'account' | 'admin' | 'user' | 'anonymous';
+export interface WhoAmI {
+    objectType: WhoAmIObjectType;
+    sessionKey?: string | null;
+    timeoutMinutes?: number | null;
+    token?: string | null;
+    expires?: boolean | null;
+    [key: string]: unknown;
+}
+export interface RegistrationResult {
+    whoAmI: WhoAmI;
+    redirectUrl?: string | null;
+}
+export type TeamRole = 'OWNER' | 'AUTHOR' | 'SUPPORT' | 'ASSOCIATE';
+/**
+ * Currently the API only supports `SAML`. This type is intentionally narrow so that adding new
+ * protocols on the backend requires an explicit type update here.
+ */
+export type SsoProtocol = 'SAML';
+/**
+ * Gets registration info for a self-registration token.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/self/{token}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * const info = await registrationAdapter.getSelfRegistrationInfo('my-token');
+ *
+ * @param token         Self-registration token
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to registration info
+ */
+export declare function getSelfRegistrationInfo(token: string, optionals?: RoutingOptions): Promise<RegistrationInfo>;
+/**
+ * Completes a self-registration using a token.
+ * Base URL: PATCH `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/self/{token}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * const result = await registrationAdapter.completeSelfRegistration('my-token', 'secret123', {
+ *     displayName: 'John Doe',
+ *     handle: 'johnd',
+ * });
+ *
+ * @param token                     Self-registration token
+ * @param password                  Password for the new account
+ * @param [optionals]               Optional arguments; pass network call options overrides here.
+ * @param [optionals.displayName]   Display name for the new user
+ * @param [optionals.givenName]     Given name for the new user
+ * @param [optionals.familyName]    Family name for the new user
+ * @param [optionals.handle]        Handle for the new user
+ * @returns promise that resolves to the registration result including session info
+ */
+export declare function completeSelfRegistration(token: string, password: string, optionals?: {
+    displayName?: string;
+    givenName?: string;
+    familyName?: string;
+    handle?: string;
+} & RoutingOptions): Promise<RegistrationResult>;
+/**
+ * Sends a self-registration invite email to a user. Pass an `Accept-Language` header via
+ * `optionals.headers` to localize the email.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/self/{groupKey}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * await registrationAdapter.sendSelfRegistrationInvite('group-key', 'user@example.com', {
+ *     linkDestination: 'DASHBOARD',
+ *     redirectUrl: 'https://app.example.com',
+ *     headers: { 'Accept-Language': 'fr-FR' },
+ * });
+ *
+ * @param groupKey                      Group key to register the user into
+ * @param email                         Email address of the user to invite
+ * @param [optionals]                   Optional arguments; pass network call options overrides here.
+ * @param [optionals.linkDestination]   Destination for the registration link ('DASHBOARD' or 'MANAGER')
+ * @param [optionals.modality]          Registration modality
+ * @param [optionals.redirectUrl]       URL to redirect to after registration
+ * @param [optionals.subject]           Subject line for the invite email
+ * @param [optionals.givenName]         Pre-populate given name in the registration form
+ * @param [optionals.familyName]        Pre-populate family name in the registration form
+ * @param [optionals.linkUrl]           Custom URL to use for the registration link
+ * @param [optionals.confirmation]      Whether to send a confirmation email
+ * @returns promise that resolves to undefined if successful
+ */
+export declare function sendSelfRegistrationInvite(groupKey: string, email: string, optionals?: {
+    linkDestination?: 'DASHBOARD' | 'MANAGER';
+    modality?: 'NONE' | 'HBP' | 'ICC' | 'SSO';
+    redirectUrl?: string;
+    subject?: string;
+    givenName?: string;
+    familyName?: string;
+    linkUrl?: string;
+    confirmation?: boolean;
+} & RoutingOptions): Promise<void>;
+/**
+ * Gets registration info for an invite token.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/invite/{token}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * const info = await registrationAdapter.getInviteRegistrationInfo('invite-token');
+ *
+ * @param token         Invite registration token
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to registration info
+ */
+export declare function getInviteRegistrationInfo(token: string, optionals?: RoutingOptions): Promise<RegistrationInfo>;
+/**
+ * Completes an invite registration using a token.
+ * Base URL: PATCH `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/invite/{token}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * const result = await registrationAdapter.completeInviteRegistration('invite-token', 'pass456', {
+ *     displayName: 'Jane Doe',
+ * });
+ *
+ * @param token                     Invite registration token
+ * @param password                  Password for the new account
+ * @param [optionals]               Optional arguments; pass network call options overrides here.
+ * @param [optionals.displayName]   Display name for the new user
+ * @param [optionals.givenName]     Given name for the new user
+ * @param [optionals.familyName]    Family name for the new user
+ * @param [optionals.handle]        Handle for the new user
+ * @returns promise that resolves to the registration result including session info
+ */
+export declare function completeInviteRegistration(token: string, password: string, optionals?: {
+    displayName?: string;
+    givenName?: string;
+    familyName?: string;
+    handle?: string;
+} & RoutingOptions): Promise<RegistrationResult>;
+/**
+ * Sends an invite registration email to a user. Pass an `Accept-Language` header via
+ * `optionals.headers` to localize the email.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/invite/{groupKey}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * await registrationAdapter.sendInvite('group-key', 'invited@example.com', {
+ *     givenName: 'New',
+ *     familyName: 'User',
+ *     redirectUrl: 'https://app.example.com',
+ * });
+ *
+ * @param groupKey                      Group key to invite the user into
+ * @param email                         Email address of the user to invite
+ * @param [optionals]                   Optional arguments; pass network call options overrides here.
+ * @param [optionals.linkDestination]   Destination for the registration link ('DASHBOARD' or 'MANAGER')
+ * @param [optionals.modality]          Registration modality
+ * @param [optionals.redirectUrl]       URL to redirect to after registration
+ * @param [optionals.subject]           Subject line for the invite email
+ * @param [optionals.givenName]         Pre-populate given name in the registration form
+ * @param [optionals.familyName]        Pre-populate family name in the registration form
+ * @param [optionals.linkUrl]           Custom URL to use for the registration link
+ * @param [optionals.confirmation]      Whether to send a confirmation email
+ * @returns promise that resolves to undefined if successful
+ */
+export declare function sendInvite(groupKey: string, email: string, optionals?: {
+    linkDestination?: 'DASHBOARD' | 'MANAGER';
+    modality?: 'NONE' | 'HBP' | 'ICC' | 'SSO';
+    redirectUrl?: string;
+    subject?: string;
+    givenName?: string;
+    familyName?: string;
+    linkUrl?: string;
+    confirmation?: boolean;
+} & RoutingOptions): Promise<void>;
+/**
+ * Gets registration info for a team invite token.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/team/{token}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * const info = await registrationAdapter.getTeamRegistrationInfo('team-token');
+ *
+ * @param token         Team invite token
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to team registration info
+ */
+export declare function getTeamRegistrationInfo(token: string, optionals?: RoutingOptions): Promise<TeamRegistrationInfo>;
+/**
+ * Sends a team invite email. Pass an `Accept-Language` header via `optionals.headers` to
+ * localize the email.
+ * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/team`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * await registrationAdapter.sendTeamInvite(
+ *     'Jane Author',
+ *     'AUTHOR',
+ *     'https://app.example.com',
+ *     'newteammate@example.com',
+ *     { subject: 'Welcome to the team!' },
+ * );
+ *
+ * @param invitingAuthor            Name or identifier of the person sending the invite
+ * @param role                      Role to assign to the invited user
+ * @param redirectUrl               URL to redirect to after accepting the invite
+ * @param email                     Email address of the user to invite
+ * @param [optionals]               Optional arguments; pass network call options overrides here.
+ * @param [optionals.subject]       Subject line for the invite email
+ * @param [optionals.givenName]     Pre-populate given name for the invited user
+ * @param [optionals.familyName]    Pre-populate family name for the invited user
+ * @returns promise that resolves to undefined if successful
+ */
+export declare function sendTeamInvite(invitingAuthor: string, role: TeamRole, redirectUrl: string, email: string, optionals?: {
+    subject?: string;
+    givenName?: string;
+    familyName?: string;
+} & RoutingOptions): Promise<void>;
+/**
+ * @deprecated Use getSsoAdminRegistration or getSsoUserRegistration instead.
+ * Gets SSO registration info for a given SSO protocol.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/sso/{ssoProtocol}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * const info = await registrationAdapter.getSsoRegistration('SAML');
+ *
+ * @param ssoProtocol   The SSO protocol (e.g. 'SAML')
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to SSO registration data
+ */
+export declare function getSsoRegistration(ssoProtocol: SsoProtocol, optionals?: RoutingOptions): Promise<unknown>;
+/**
+ * Gets admin SSO registration info for a given SSO protocol.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/sso/admin/{ssoProtocol}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * const info = await registrationAdapter.getSsoAdminRegistration('SAML');
+ *
+ * @param ssoProtocol   The SSO protocol (e.g. 'SAML')
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to SSO admin registration data
+ */
+export declare function getSsoAdminRegistration(ssoProtocol: SsoProtocol, optionals?: RoutingOptions): Promise<unknown>;
+/**
+ * Gets user SSO registration info for a given SSO protocol.
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/registration/sso/user/{ssoProtocol}`
+ *
+ * @example
+ * import { registrationAdapter } from 'epicenter-libs';
+ * const info = await registrationAdapter.getSsoUserRegistration('SAML');
+ *
+ * @param ssoProtocol   The SSO protocol (e.g. 'SAML')
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to SSO user registration data
+ */
+export declare function getSsoUserRegistration(ssoProtocol: SsoProtocol, optionals?: RoutingOptions): Promise<unknown>;

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

@@ -1,12 +1,18 @@
-import type { RoutingOptions } from '../utils/router';
-import type { GenericScope, Address } from '../utils/constants';
+import type { Address, GenericScope, GenericSearchOptions } from '../utils/constants';
+import type { Page, RoutingOptions } from '../utils/router';
 export declare enum RETRY_POLICY {
     DO_NOTHING = "DO_NOTHING",// If the task fails, do nothing (this is the default)
-    RESCHEDULE = "RESCHEDULE",// If the task fails retry at the next scheduled time point
     FIRE_ON_FAIL_SAFE = "FIRE_ON_FAIL_SAFE"
 }
 export type TaskPayloadBody = Record<string, unknown>;
 export type TaskPayloadHeaders = Record<string, string>;
+export type TaskHttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export type TaskRetryPolicyReadOutView = 'do_nothing' | 'fire_on_fail_safe';
+export type TaskStatusReadOutView = 'initialized' | 'triggered' | 'succeeded' | 'failed' | 'cancelled' | 'terminated';
+export type TaskAddressReadOutView = Partial<Address>;
+export interface TaskScopeReadOutView extends GenericScope {
+    userKey?: string;
+}
 export interface StatusReadOutView {
     code?: string;
     message?: string;
@@ -32,10 +38,12 @@ export interface OffsetTaskTriggerCreateInView {
 export type TaskTriggerCreateInView = CronTaskTriggerCreateInView | DateTaskTriggerCreateInView | OffsetTaskTriggerCreateInView;
 export interface HttpTaskPayloadCreateInView<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders> {
     objectType: 'http';
-    method: string;
+    method: TaskHttpMethod;
     url: string;
+    target?: 'APPLICATION' | 'PROXY';
     body: B;
     headers?: H;
+    timeoutSeconds?: number;
 }
 export interface GroupStatusTaskPayloadCreateInView {
     objectType: 'groupStatus';
@@ -43,12 +51,18 @@ export interface GroupStatusTaskPayloadCreateInView {
     status: StatusCreateInView;
 }
 export type TaskPayloadCreateInView<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders> = HttpTaskPayloadCreateInView<B, H> | GroupStatusTaskPayloadCreateInView;
+export type HttpTaskPayloadCreateInput<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders> = Omit<HttpTaskPayloadCreateInView<B, H>, 'objectType'> & {
+    objectType?: 'http';
+};
+export type TaskPayloadCreateInput<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders> = HttpTaskPayloadCreateInput<B, H> | GroupStatusTaskPayloadCreateInView;
 export interface HttpTaskPayloadReadOutView<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders> {
     objectType: 'http';
-    method?: string;
+    method?: TaskHttpMethod;
     url?: string;
+    target?: 'application' | 'proxy';
     body?: B;
     headers?: H;
+    timeoutSeconds?: number;
 }
 export interface GroupStatusTaskPayloadReadOutView {
     objectType: 'groupStatus';
@@ -59,20 +73,34 @@ export type TaskPayloadReadOutView<B extends object = TaskPayloadBody, H extends
 export interface TaskReadOutView<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders> {
     taskKey?: string;
     name?: string;
-    status?: string;
+    status?: TaskStatusReadOutView;
     cron?: string;
     mutationKey?: string;
     failures?: number;
     successes?: number;
-    address?: Address;
+    address?: TaskAddressReadOutView;
     payload?: TaskPayloadReadOutView<B, H>;
-    scope?: GenericScope;
-    retryPolicy?: string;
+    scope?: TaskScopeReadOutView;
+    retryPolicy?: TaskRetryPolicyReadOutView;
     failSafeTermination?: string;
     ttlSeconds?: number;
 }
+export interface TaskHistoryReadOutView {
+    result?: string;
+    execution?: number;
+    response?: number;
+    success?: boolean;
+    taskId?: number;
+}
+export interface TaskPageOptions {
+    first?: number;
+    max?: number;
+}
+export interface TaskScopePageOptions extends TaskPageOptions {
+    sort?: string[];
+}
 /**
- * Creates a task; requires support level authentication
+ * Creates a task; requires facilitator (or higher) privileges
  * Base URL: POST `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/task`
  *
  * @example
@@ -84,7 +112,9 @@ export interface TaskReadOutView<B extends object = TaskPayloadBody, H extends o
  * const name = 'task-1-send-emails';
  * const payload = {
  *     method: 'POST',
- *     url: 'https://forio.com/app/forio-dev/test-project/send-out-emails',
+ *     url: '/send-out-emails',
+ *     target: 'PROXY', // fire at the project's proxy server; omit to fire at the app
+ *     body: {},
  * };
  * const trigger = {
  *     value: '0 7 15 * * ?', // triggers on day 15 7am of each month
@@ -97,11 +127,13 @@ export interface TaskReadOutView<B extends object = TaskPayloadBody, H extends o
  * @param scope.scopeKey                        Scope key, a unique identifier tied to the scope. E.g., if your `scopeBoundary` is `GROUP`, your `scopeKey` will be your `groupKey`; for `EPISODE`, `episodeKey`, etc.
  * @param [scope.userKey]                       Key associated with the user
  * @param name                                  Name of the task
- * @param payload                               An HTTP task object that will be executed when the task is triggered
- * @param payload.method                        Type of method to use with the HTTP request (e.g., 'GET', 'POST', 'PATCH')
- * @param payload.url                           The URL the HTTP request will be sent to
- * @param [payload.body]                        The body of the HTTP request
- * @param [payload.headers]                     Headers to send along with the HTTP request
+ * @param payload                               An HTTP request or group-status change to execute when the task is triggered
+ * @param payload.method                        Type of method to use with the HTTP request (e.g., 'GET', 'POST')
+ * @param payload.url                           Relative URL the HTTP request will be sent to; the task runner builds the full URL as `{host}{targetPath}/{account}/{project}{url}`
+ * @param [payload.target]                      Where the task fires: 'APPLICATION' (the project app, `/app`, the default) or 'PROXY' (the project's proxy server, `/proxy`)
+ * @param payload.body                          The JSON body of the HTTP request
+ * @param [payload.headers]                     Headers to send along with the HTTP request; must be non-empty when provided — omit rather than pass an empty object
+ * @param [payload.timeoutSeconds]               Request timeout in seconds (1–30)
  * @param trigger                               Object that determines when to run the task (cron, offset, or date)
  * @param [trigger.value]                       For cron: cron expression (e.g., '0 7 * * * ?'). For date: ISO-8601 date-time string
  * @param [trigger.objectType]                  Type of trigger: 'cron', 'offset', or 'date'
@@ -112,24 +144,19 @@ export interface TaskReadOutView<B extends object = TaskPayloadBody, H extends o
  * @param [optionals.accountShortName]          Name of account (by default will be the account associated with the session)
  * @param [optionals.projectShortName]          Name of project (by default will be the project associated with the session)
  * @param [optionals.retryPolicy]               Specifies what to do should the task fail; see RETRY_POLICY
- * @param [optionals.failSafeTermination]       The ISO-8601 date-time when the task will be deleted regardless of any triggers; defaults to null
- * @param [optionals.ttlSeconds]                Max life expectancy of the task; used to determine if retrying the task is necessary
+ * @param [optionals.failSafeTermination]       ISO-8601 deadline after which the task terminates; the server defaults and caps this at one year from creation
+ * @param [optionals.ttlSeconds]                Execution fail-safe window in seconds; the server applies its configured minimum
  * @returns promise that resolves to the task object including the taskKey
  */
 export declare function create<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders>(scope: {
     userKey?: string;
-} & GenericScope, name: string, payload: {
-    method: string;
-    url: string;
-    body?: B;
-    headers?: H;
-}, trigger: TaskTriggerCreateInView, optionals?: {
+} & GenericScope, name: string, payload: TaskPayloadCreateInput<B, H>, trigger: TaskTriggerCreateInView, optionals?: {
     retryPolicy?: keyof typeof RETRY_POLICY;
-    failSafeTermination?: number;
+    failSafeTermination?: string;
     ttlSeconds?: number;
 } & RoutingOptions): Promise<TaskReadOutView<B, H>>;
 /**
- * Deletes a task (changes status to cancelled); requires support level authentication
+ * Deletes a task (changes status to cancelled); requires facilitator (or higher) privileges
  * Base URL: DELETE `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/task/{TASK_KEY}`
  *
  * @example
@@ -138,14 +165,14 @@ export declare function create<B extends object = TaskPayloadBody, H extends obj
  * await taskAdapter.destroy(taskKey);
  *
  * @param taskKey                               Unique key associated with a task
- * @param [optionals]                           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals]                           Optional arguments; pass network call options overrides here.
  * @param [optionals.accountShortName]          Name of account (by default will be the account associated with the session)
  * @param [optionals.projectShortName]          Name of project (by default will be the project associated with the session)
  * @returns promise that resolves to undefined when successful
  */
 export declare function destroy(taskKey: string, optionals?: RoutingOptions): Promise<void>;
 /**
- * Gets a task by taskKey; requires support level authentication
+ * Gets a task by taskKey; requires facilitator (or higher) privileges
  * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/task/{TASK_KEY}`
  *
  * @example
@@ -154,14 +181,14 @@ export declare function destroy(taskKey: string, optionals?: RoutingOptions): Pr
  * const task = await taskAdapter.get(taskKey);
  *
  * @param taskKey                               Unique key associated with a task
- * @param [optionals]                           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals]                           Optional arguments; pass network call options overrides here.
  * @param [optionals.accountShortName]          Name of account (by default will be the account associated with the session)
  * @param [optionals.projectShortName]          Name of project (by default will be the project associated with the session)
  * @returns promise that resolves to the task object
  */
 export declare function get<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders>(taskKey: string, optionals?: RoutingOptions): Promise<TaskReadOutView<B, H>>;
 /**
- * Gets the history (100 most recent times it has triggered) of a task by taskKey; requires support level authentication
+ * Gets the history (100 most recent times it has triggered) of a task by taskKey; requires facilitator (or higher) privileges
  * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/task/history/{TASK_KEY}`
  *
  * @example
@@ -170,14 +197,16 @@ export declare function get<B extends object = TaskPayloadBody, H extends object
  * const history = await taskAdapter.getHistory(taskKey);
  *
  * @param taskKey                               Unique key associated with a task
- * @param [optionals]                           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals]                           Pagination and network options
+ * @param [optionals.first]                     Zero-based index of the first history record; defaults to 0
+ * @param [optionals.max]                       Maximum history records to return; defaults to 100 and cannot exceed 100
  * @param [optionals.accountShortName]          Name of account (by default will be the account associated with the session)
  * @param [optionals.projectShortName]          Name of project (by default will be the project associated with the session)
- * @returns promise that resolves to an array of task history objects
+ * @returns promise that resolves to a page of task history objects
  */
-export declare function getHistory<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders>(taskKey: string, optionals?: RoutingOptions): Promise<TaskReadOutView<B, H>[]>;
+export declare function getHistory(taskKey: string, optionals?: TaskPageOptions & RoutingOptions): Promise<Page<TaskHistoryReadOutView>>;
 /**
- * Gets most recent 100 tasks related to the selected scope; requires support level authentication
+ * Gets most recent 100 tasks related to the selected scope; requires facilitator (or higher) privileges
  * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/task/in/{SCOPE_BOUNDARY}/{SCOPE_KEY}` or GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/task/in/{SCOPE_BOUNDARY}/{SCOPE_KEY}/{USER_KEY}`
  *
  * Note: Will retrieve all tasks that were CREATED in the specified scope. If something was created with episode scope, it will not be retrievable through group scoping.
@@ -194,11 +223,44 @@ export declare function getHistory<B extends object = TaskPayloadBody, H extends
  * @param scope.scopeBoundary                   Scope boundary, defines the type of scope; See [scope boundary](#SCOPE_BOUNDARY) for all types
  * @param scope.scopeKey                        Scope key, a unique identifier tied to the scope. E.g., if your `scopeBoundary` is `GROUP`, your `scopeKey` will be your `groupKey`; for `EPISODE`, `episodeKey`, etc.
  * @param [scope.userKey]                       Key associated with the user; will retrieve tasks in the scope that were made by the specified user
- * @param [optionals]                           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals]                           Pagination, sorting, and network options
+ * @param [optionals.sort]                      Task fields to sort by
+ * @param [optionals.first]                     Zero-based index of the first task; defaults to 0
+ * @param [optionals.max]                       Maximum tasks to return; defaults to 100 and cannot exceed 100
  * @param [optionals.accountShortName]          Name of account (by default will be the account associated with the session)
  * @param [optionals.projectShortName]          Name of project (by default will be the project associated with the session)
- * @returns promise that resolves to an array of task objects
+ * @returns promise that resolves to a page of task objects
  */
 export declare function getTaskIn<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders>(scope: {
     userKey?: string;
-} & GenericScope, optionals?: RoutingOptions): Promise<TaskReadOutView<B, H>[]>;
+} & GenericScope, optionals?: TaskScopePageOptions & RoutingOptions): Promise<Page<TaskReadOutView<B, H>>>;
+/**
+ * Queries for tasks
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/task/search`
+ *
+ * No authentication is required; results use facilitator-level row visibility.
+ * Filterable/sortable fields include
+ * `task.taskKey`, `task.name`, `task.status`, `task.scopeBoundary`, `task.scopeKey`,
+ * `task.userKey`, `task.groupName`, `task.episodeName`, `task.nextExecution`,
+ * `task.failSafeExecution`, and `task.created`.
+ *
+ * @example
+ * import { taskAdapter } from 'epicenter-libs';
+ * const page = await taskAdapter.query({
+ *     filter: [
+ *         'task.scopeKey=0000017dd3bf540e5ada5b1e058f08f20461',    // tasks scoped to this group
+ *         'task.status=INITIALIZED',                               // that have not yet fired
+ *     ],
+ *     sort: ['-task.created'],    // newest first
+ *     max: 10,                    // page should only include the first 10 items
+ * });
+ *
+ * @param searchOptions                         Search options for the query
+ * @param [searchOptions.filter]                Filters for searching
+ * @param [searchOptions.sort]                  Sorting criteria
+ * @param [searchOptions.first]                 The starting index of the page returned
+ * @param [searchOptions.max]                   The number of entries per page
+ * @param [optionals]                           Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to a page of tasks
+ */
+export declare function query<B extends object = TaskPayloadBody, H extends object = TaskPayloadHeaders>(searchOptions: GenericSearchOptions, optionals?: RoutingOptions): Promise<Page<TaskReadOutView<B, H>>>;