Type Definitions

This page provides a comprehensive list of all the type definitions used throughout the scripts. Each type is documented with its structure and, where applicable, links to other dependent types. This documentation serves as a reference for understanding the various data structures and their relationships used within the platform.

AfterDeleteInput

export type AfterDeleteInput<T> = { datasourceId: string; rows: DBRow<T>[] };

AfterDeleteOutput

export type AfterDeleteOutput<T> = { rows: T[] };

AfterInsertInput

export type AfterInsertInput<T> = { datasourceId: string; rows: DBRow<T>[] };

AfterInsertOutput

export type AfterInsertOutput<T> = { rows: T[] };

AfterUpdateInput

export type AfterUpdateInput<T> = { datasourceId: string; rows: DBRow<T>[] };

AfterUpdateOutput

export type AfterUpdateOutput<T> = { rows: T[] };

Aggregate

export type Aggregate<T> = { aggregateFunction: AggregateFunction; attributeCode: keyof T; intoAttributeCode: keyof T };

AggregateFunction

export type AggregateFunction = 'Avg' | 'Count' | 'DistinctCount' | 'Max' | 'Min' | 'Sum';

AppConfig

export type AppConfig = {
  instance_id_prefix: string;
  secret: { data: string; jwt: string; argon: string };
  encrypted_args: boolean;
  smtp?: {
    host: string;
    port?: number;
    from_email: string;
    provider: { Gmail: string } | 'Others';
    use_tls: boolean;
    username?: string;
    password?: string;
  };
  http: {
    enabled: boolean;
    host: string;
    port: number;
    allowed_origins?: Array<string>;
    default_host: string;
    map_unknown_hosts_to_default: boolean;
    max_concurrent_requests: number;
    api_rate_limit_per_hour: number;
    static_rate_limit_per_hour: number;
    allow_public_tiny_urls: boolean;
    upload_max_mb: number;
    allow_sql_worksheet_updates: boolean;
    x_frame_option: 'DENY' | 'SameOrigin' | 'NONE';
  };
  env: 'production' | 'development' | 'test';
  init?: { admin_email: string; admin_password: string };
  deno: {
    port: number;
    timeout_seconds: number;
    initial_old_space_size: number;
    max_old_space_size: number;
    initial_heap_size: number;
    max_heap_size: number;
    max_workers: number;
    web_host: string;
    web_port: number;
    web_dev: boolean;
    web_enabled: boolean;
    web_inspect?: string;
  };
  python: { timeout_seconds: number };
  worker: { enabled: boolean; max_parallel_tasks: number; total_workers: number };
  flow_triggers: { enabled: boolean; total_kafka_consumers: number };
  db: {
    min_connections: number;
    max_connections: number;
    idle_timeout_seconds: bigint;
    max_lifetime_seconds: bigint;
    acquire_timeout_seconds: bigint;
    slow_statements_duration_seconds: bigint;
    sql_rate_limit_per_minute: number;
    sql_timeout_seconds: bigint;
    log_sql: boolean;
  };
  log: string;
  tmp_dir: string;
  thumb_dir: string;
  stack_size_in_mb: number;
  load_test_mode: boolean;
};

Approval

export type Approval = {
  approvers: string;
  minimumApprovalsRequired: number;
  reminderUnit: 'Second' | 'Hour' | 'Day';
  reminderFrequency: number;
  timeoutAfterNReminders: number;
  onRequest: string;
  onResponse: string;
};

ApprovalEmail

export type ApprovalEmail = { subject: string; textBody: string; htmlBody?: string };

ApprovalInfo

export type ApprovalInfo = {
  executionId: string;
  flowId: string;
  flowRunId: string;
  nodeId: string;
  nodeType: string;
  version: number;
  workspaceId: string;
  approver: string;
};

ApprovalResponse

export type ApprovalResponse = {
  executionId: string;
  flowId: string;
  flowRunId: string;
  nodeId: string;
  nodeType: string;
  version: number;
  workspaceId: string;
  approver: string;
  approvalStatus: ApprovalResult;
  rejectReason?: string;
};

ApprovalResult

export type ApprovalResult = 'Approved' | 'Rejected' | 'Timeout' | 'Cancelled' | 'Pending';

ApproversInfo

export type ApproversInfo = {
  approvers: Array<string>;
  urlState: Record<string, any>;
  pageId: string;
  workspaceId: string;
};

Attribute

export type Attribute = {
  orgId: string;
  workspaceId: string;
  datasourceId: string;
  attributeId: string;
  attributeCode: string;
  attributeName: string;
  attributeType: AttributeType;
  columnName?: string;
  seqNo: number;
  insertAllowed: YN;
  updateAllowed: YN;
  selectAllowed: YN;
  exportAllowed: YN;
  queryAllowed: YN;
  auditEnabled: YN;
  primaryKey: YN;
  autoSequence: YN;
  allowBlank: YN;
  maxLength?: number;
  defaultValue?: string;
  paramName?: string;
  outParam: YN;
  scale?: number;
  minValue?: number;
  maxValue?: number;
  calculatedColumn: YN;
  noUppercaseSearch: YN;
  createdAt: string;
  createdBy: string;
  updatedAt: string;
  updatedBy: string;
  tag?: string;
  refMd?: ReferenceMetadata;
  refAlias?: string;
  refFromClause?: string;
  refWhereClause?: string;
  enumValues?: Array<string>;
};

AttributeOption

export type AttributeOption = {
  orgId?: string;
  workspaceId?: string;
  datasourceId?: string;
  attributeId?: string;
  attributeCode?: string;
  attributeName?: string;
  attributeType?: AttributeType;
  columnName?: string;
  seqNo?: number;
  insertAllowed?: YN;
  updateAllowed?: YN;
  selectAllowed?: YN;
  exportAllowed?: YN;
  queryAllowed?: YN;
  auditEnabled?: YN;
  primaryKey?: YN;
  autoSequence?: YN;
  allowBlank?: YN;
  maxLength?: number;
  defaultValue?: string;
  paramName?: string;
  outParam?: YN;
  scale?: number;
  minValue?: number;
  maxValue?: number;
  calculatedColumn?: YN;
  noUppercaseSearch?: YN;
  createdAt?: string;
  createdBy?: string;
  updatedAt?: string;
  updatedBy?: string;
  tag?: string;
  refMd?: ReferenceMetadata;
  refAlias?: string;
  refFromClause?: string;
  refWhereClause?: string;
  enumValues?: Array<string>;
};

AttributeType

export type AttributeType =
  | 'Address'
  | 'Binary'
  | 'Boolean'
  | 'Currency'
  | 'Date'
  | 'DateTime'
  | 'Decimal'
  | 'Double'
  | 'Email'
  | 'EncryptedString'
  | 'Integer'
  | 'IntegerArray'
  | 'JSON'
  | 'Location'
  | 'Password'
  | 'Percent'
  | 'Phone'
  | 'Reference'
  | 'String'
  | 'StringArray'
  | 'Textarea'
  | 'Time'
  | 'URL'
  | 'UUID'
  | { Unknown: string | null }
  | 'UserID'
  | 'YN'
  | { Enum: string }
  | 'Attachment'
  | 'TF';

Audit

export type Audit = {
  orgId: string;
  workspaceId: string;
  datasourceId: string;
  pkValue: string;
  attributeCode: string;
  valueType: AuditValueType;
  oldStringValue?: string;
  newStringValue?: string;
  oldClobValue?: string;
  newClobValue?: string;
  oldDoubleValue?: number;
  newDoubleValue?: number;
  oldDatetimeValue?: string;
  newDatetimeValue?: string;
  updatedAt: string;
  updatedBy: string;
  auditId: number;
};

AuditOption

export type AuditOption = {
  orgId?: string;
  workspaceId?: string;
  datasourceId?: string;
  pkValue?: string;
  attributeCode?: string;
  valueType?: AuditValueType;
  oldStringValue?: string;
  newStringValue?: string;
  oldClobValue?: string;
  newClobValue?: string;
  oldDoubleValue?: number;
  newDoubleValue?: number;
  oldDatetimeValue?: string;
  newDatetimeValue?: string;
  updatedAt?: string;
  updatedBy?: string;
  auditId?: number;
};

AuditValueType

export type AuditValueType = 'String' | 'Clob' | 'Double' | 'DateTime';

AuthTypes

export type AuthTypes = 'OAUTH' | 'NATIVE' | 'SAML';

BeforeDeleteInput

export type BeforeDeleteInput<T> = { datasourceId: string; rows: DBRow<T>[] };

BeforeDeleteOutput

export type BeforeDeleteOutput<T> = { rows: T[]; skipDML: boolean; sql?: string; params?: unknown[] };

BeforeInsertInput

export type BeforeInsertInput<T> = { datasourceId: string; rows: T[] };

BeforeInsertOutput

export type BeforeInsertOutput<T> = { rows: T[]; skipDML: boolean; sql?: string; params?: unknown[] };

BeforeUpdateInput

export type BeforeUpdateInput<T> = { datasourceId: string; rows: DBRow<T>[] };

BeforeUpdateOutput

export type BeforeUpdateOutput<T> = { rows: T[]; skipDML: boolean; sql?: string; params?: unknown[] };

BooleanFilter

export type BooleanFilter = { istrue: boolean } | { empty: boolean } | { notempty: boolean };

ClientSession

export type ClientSession = {
  orgId: string;
  sessionId: string;
  userName: string;
  displayName: string;
  locationName?: string;
  email: string;
  x: string;
  jwt: string;
  status: 'OK';
  workspaces: Array<UserWorkspaces>;
  settings: UserSettings;
};

Color

export type Color = { base: string; dark: string };

Column

export type Column = {
  key: string;
  code: string;
  name: string;
  columnName: string;
  attributeType: AttributeType;
  optional: boolean;
  maxLength?: number;
  dateFormat?: string;
  primaryKey?: boolean;
  autoSequence?: boolean;
};

Create

export type Create =
  | { type: 'Workspace'; row: Workspace }
  | { type: 'Flow'; row: Flows }
  | { type: 'FlowDraft'; row: FlowVersion };

CreateResult

export type CreateResult =
  | { type: 'Flow'; row: Flows }
  | { type: 'FlowVersion'; row: number }
  | { type: 'Workspace'; row: Workspace };

DBResource

export type DBResource = {
  orgId: string;
  workspaceId: string;
  resource: string;
  dbType: DBType;
  props: DBResourceProps;
};

DBResourceProps

export type DBResourceProps =
  | { MySQL: MySQLProps }
  | { SQLServer: SQLServerProps }
  | { Postgres: PostgresProps }
  | { Oracle: OracleProps };

DBType

export type DBType = 'MySQL' | 'SQLServer' | 'Postgres' | 'Oracle';

DSPost

export type DSPost<T> = { datasourceId: string; rows: DBRow<T>[]; transaction?: Transaction };

DSQuery

export type DSQuery<T> = { datasourceId: string; query: Query<T> };

DSRequest

export type DSRequest<T> = DSQuery<T> | DSPost<T>;

DataSource

export type DataSource = {
  orgId: string;
  workspaceId: string;
  datasourceId: string;
  datasourceType: DatasourceType;
  typeValue: string;
  logLevel?: string;
  preQueryScript?: string;
  postQueryScript?: string;
  skipQueryForUpdate: YN;
  createdAt: string;
  createdBy: string;
  updatedAt: string;
  updatedBy: string;
  beforeInsertScript?: string;
  afterInsertScript?: string;
  beforeUpdateScript?: string;
  afterUpdateScript?: string;
  beforeDeleteScript?: string;
  afterDeleteScript?: string;
  sampleData?: string;
  preventResync: YN;
  readOnly: YN;
  validateRowScript?: string;
  extTypeValue?: string;
  attributes: Array<Attribute>;
  access: Array<DataSourceAccess>;
};

DataSourceAccess

export type DataSourceAccess = {
  orgId: string;
  workspaceId: string;
  roleId: string;
  datasourceId: string;
  startDate: string;
  endDate?: string;
  createdAt: string;
  createdBy: string;
  updatedAt: string;
  updatedBy: string;
  queryAllowed: YN;
  insertAllowed: YN;
  updateAllowed: YN;
  deleteAllowed: YN;
  auditAllowed: YN;
  exportAllowed: YN;
  publicDownloadAllowed: YN;
};

DataSourceAccessOption

export type DataSourceAccessOption = {
  orgId?: string;
  workspaceId?: string;
  roleId?: string;
  datasourceId?: string;
  startDate?: string;
  endDate?: string;
  createdAt?: string;
  createdBy?: string;
  updatedAt?: string;
  updatedBy?: string;
  queryAllowed?: YN;
  insertAllowed?: YN;
  updateAllowed?: YN;
  deleteAllowed?: YN;
  auditAllowed?: YN;
  exportAllowed?: YN;
  publicDownloadAllowed?: YN;
};

DataSourceInternal

export type DataSourceInternal = {
  orgId: string;
  workspaceId: string;
  datasourceId: string;
  datasourceType: string;
  typeValue: string;
  logLevel?: string;
  preQueryScript?: string;
  postQueryScript?: string;
  skipQueryForUpdate: YN;
  createdAt: string;
  createdBy: string;
  updatedAt: string;
  updatedBy: string;
  beforeInsertScript?: string;
  afterInsertScript?: string;
  beforeUpdateScript?: string;
  afterUpdateScript?: string;
  beforeDeleteScript?: string;
  afterDeleteScript?: string;
  sampleData?: string;
  preventResync: YN;
  readOnly: YN;
  validateRowScript?: string;
  extTypeValue?: string;
};

DataSourceInternalOption

export type DataSourceInternalOption = {
  orgId?: string;
  workspaceId?: string;
  datasourceId?: string;
  datasourceType?: string;
  typeValue?: string;
  logLevel?: string;
  preQueryScript?: string;
  postQueryScript?: string;
  skipQueryForUpdate?: YN;
  createdAt?: string;
  createdBy?: string;
  updatedAt?: string;
  updatedBy?: string;
  beforeInsertScript?: string;
  afterInsertScript?: string;
  beforeUpdateScript?: string;
  afterUpdateScript?: string;
  beforeDeleteScript?: string;
  afterDeleteScript?: string;
  sampleData?: string;
  preventResync?: YN;
  readOnly?: YN;
  validateRowScript?: string;
  extTypeValue?: string;
};

DatasourceType

export type DatasourceType = 'Table' | { External: ExternalDatasource };

DateFilter

export type DateFilter =
  | { on: string }
  | { noton: string }
  | { empty: string }
  | { notempty: string }
  | { after: string }
  | { before: string }
  | { beforetime: string }
  | { onorafter: string }
  | { onorbefore: string }
  | { today: string }
  | { yesterday: string }
  | { last7days: string }
  | { last14days: string }
  | { last28days: string }
  | { thisweek: string }
  | { thismonth: string }
  | { thisquarter: string }
  | { thisyear: string };

Delete

export type Delete = { type: 'Flow'; row: string } | { type: 'FlowVersion'; row: FlowVersion };

DeleteResult

export type DeleteResult = { type: 'Empty' };

Direction

export type Direction = 'ltr' | 'rtl';

DownloadPatchIds

export type DownloadPatchIds = {
  pages: Array<string>;
  dataSources: Array<string>;
  flows: Array<string>;
  scripts: Array<string>;
  testScripts: Array<string>;
  profiles: Array<string>;
  roles: Array<string>;
  lookups: Array<string>;
  languages: Array<string>;
  flowNodes: Array<string>;
  externalDataSources: Array<string>;
  images: Array<string>;
  settings: boolean;
  components?: Array<string>;
  componentSources?: Array<string>;
  dbScripts?: Array<string>;
  howTos?: Array<string>;
  resources: Array<string>;
  resourceTypes: Array<string>;
  variables: Array<string>;
};

Edge

export type Edge = { id: string; label?: string; source: string; target: string };

EmailProps

export type EmailProps = {
  to: string;
  cc?: string;
  bcc?: string;
  subject: string;
  text: string;
  html?: string;
  attachments?: Array<string>;
};

ErrorResult

export type ErrorResult = { title: string; message: string; code: number; status: 'ERROR' };

ExecuteDenoNodeScriptInput

export type ExecuteDenoNodeScriptInput<T> = { script: string; input: T };

ExecuteDenoNodeScriptOutput

export type ExecuteDenoNodeScriptOutput = { row: Record<string, unknown> };

ExecuteOnErrorScheduledScriptInput

export type ExecuteOnErrorScheduledScriptInput = { scheduleId: string; error: string; scriptUri: string };

ExecuteScheduledScriptInput

export type ExecuteScheduledScriptInput = { scriptUri: string; body: Record<string, unknown> };

ExecuteScriptInput

export type ExecuteScriptInput = {
  scriptUri: string;
  body: Record<string, unknown>;
  headers: { [key: string]: string };
  params: { [key: string]: string };
};

ExecuteScriptOutput

export type ExecuteScriptOutput = {
  responseBody: any;
  responseType?: 'json' | 'text' | 'base64';
  responseHeaders?: Record<string, string>;
};

Execution

export type Execution = {
  endDate?: string;
  id: string;
  input: Record<string, unknown>;
  ms: number;
  next: Array<ExecutionID>;
  outcome: Outcome;
  output?: any;
  waitState?: WaitState;
  previous?: ExecutionID;
  startDate: string;
  ts: string;
  index: number;
};

ExecutionID

export type ExecutionID = { id: string; nodeId: string };

ExtAttribute

export type ExtAttribute = {
  allowBlank?: YN;
  attributeCode: string;
  attributeName: string;
  attributeType: AttributeType;
  auditEnabled?: YN;
  autoSequence?: YN;
  columnName?: string;
  defaultValue?: string;
  exportAllowed?: YN;
  insertAllowed?: YN;
  maxLength?: number;
  outParam?: YN;
  paramName?: string;
  primaryKey?: YN;
  queryAllowed?: YN;
  scale?: number;
  selectAllowed?: YN;
  updateAllowed?: YN;
  calculatedColumn?: YN;
};

ExtDescAPIInput

export type ExtDescAPIInput = { externalDsId: string; objectName?: string; initData: Record<string, any> };

ExtDescAPIOutput

export type ExtDescAPIOutput = { attrs: Array<ExtAttribute> };

ExtInitAPIInput

export type ExtInitAPIInput = { externalDsId: string; objectName?: string };

ExtInitAPIOutput

export type ExtInitAPIOutput = { row: Record<string, any> };

ExtPostAPIInput

export type ExtPostAPIInput<T> = {
  externalDsId: string;
  objectName?: string;
  rows: Row<T>[];
  initData: Record<string, unknown>;
  attributes: Array<Attribute>;
};

ExtPostAPIOutput

export type ExtPostAPIOutput<T> = { rows: T[]; sql?: string; params?: unknown[] };

ExtQueryAPIInput

export type ExtQueryAPIInput<T> = {
  externalDsId: string;
  objectName?: string;
  query: Query<T>;
  initData: Record<string, unknown>;
  attributes: Array<Attribute>;
};

ExtQueryAPIOutput

export type ExtQueryAPIOutput<T> = { rows: T[]; sql?: string; params?: unknown[] };

ExternalDatasource

export type ExternalDatasource = {
  orgId: string;
  workspaceId: string;
  externalDsId: string;
  authApi?: string;
  describeApi?: string;
  queryApi?: string;
  postApi?: string;
  createdAt: string;
  createdBy: string;
  updatedAt: string;
  updatedBy: string;
};

Flow

export type Flow = { nodes: { [key: string]: Node }; edges: { [key: string]: Edge } };

FlowAccess

export type FlowAccess = {
  createdAt: string;
  createdBy: string;
  endDate?: string;
  flowId: string;
  roleCode: string;
  startDate: string;
  updateAllowed: boolean;
  updatedAt: string;
  updatedBy: string;
};

FlowAccessOption

export type FlowAccessOption = {
  createdAt?: string;
  createdBy?: string;
  endDate?: string;
  flowId?: string;
  roleCode?: string;
  startDate?: string;
  updateAllowed?: boolean;
  updatedAt?: string;
  updatedBy?: string;
};

FlowRun

export type FlowRun = {
  id: string;
  flowId: string;
  version: number;
  name: string;
  ownerContext: string;
  status: FlowRunStatus;
  runtime: FlowRunInstance;
  timeUsageMs: bigint;
  memoryUsageBytes: bigint;
  startedAt: string;
  finishedAt?: string;
  input: Record<string, unknown>;
  store: Record<string, unknown>;
};

FlowRunInstance

export type FlowRunInstance = { nodes: { [key: string]: NodeInstance } };

FlowRunLogs

export type FlowRunLogs = { flowRunId: number; nodeId: string; executionId: string; output: string; error: string };

FlowRunOption

export type FlowRunOption = {
  id?: string;
  flowId?: string;
  version?: number;
  name?: string;
  ownerContext?: string;
  status?: FlowRunStatus;
  runtime?: FlowRunInstance;
  timeUsageMs?: bigint;
  memoryUsageBytes?: bigint;
  startedAt?: string;
  finishedAt?: string;
  input?: Record<string, unknown>;
  store?: Record<string, unknown>;
};

FlowRunStatus

export type FlowRunStatus = 'Running' | 'Success' | 'Error' | 'Cancelled' | 'TimedOut' | 'Scheduled' | 'Waiting';

FlowRunTriggered

export type FlowRunTriggered = { version: number; flowRunId: string };

FlowRunUpdated

export type FlowRunUpdated =
  | { type: 'Execution'; nodeId: string; execution: Execution }
  | { type: 'Node'; nodeId: string; node: NodeInstance }
  | { type: 'ExecutionSeqAdded'; nodeId: string; executionId: string }
  | { type: 'ExecutionOutcome'; nodeId: string; executionId: string; outcome: Outcome }
  | { type: 'RefreshExecution'; nodeId: string; executionId: string }
  | { type: 'FlowCompleted' };

FlowStats

export type FlowStats = {
  createdAt: string;
  createdBy: string;
  flowId: string;
  maxMemoryUsageBytes: number;
  minMemoryUsageBytes: number;
  totalCancelled: number;
  totalDurationMs: number;
  totalError: number;
  totalRuns: number;
  totalSuccess: number;
  totalTimedOut: number;
  updatedAt: string;
  updatedBy: string;
  version: number;
};

FlowStatsOption

export type FlowStatsOption = {
  createdAt?: string;
  createdBy?: string;
  flowId?: string;
  maxMemoryUsageBytes?: number;
  minMemoryUsageBytes?: number;
  totalCancelled?: number;
  totalDurationMs?: number;
  totalError?: number;
  totalRuns?: number;
  totalSuccess?: number;
  totalTimedOut?: number;
  updatedAt?: string;
  updatedBy?: string;
  version?: number;
};

FlowStatus

export type FlowStatus = 'Draft' | 'Published' | 'Archived';

FlowTriggers

export type FlowTriggers = {
  activeVersion: number;
  id: string;
  name: string;
  trigger?: TriggerOption;
  updatedBy: string;
};

FlowTriggersOption

export type FlowTriggersOption = {
  activeVersion?: number;
  id?: string;
  name?: string;
  trigger?: TriggerOption;
  updatedBy?: string;
};

FlowUpdate

export type FlowUpdate = { id: string; version: number; updatedAt: string; value: FlowValue };

FlowValue

export type FlowValue =
  | { name: string }
  | { description: string }
  | { status: FlowStatus }
  | { flow: Flow }
  | { trigger: { trigger?: TriggerOption; active: boolean } };

FlowVersion

export type FlowVersion = { id: string; version: number };

FlowWaitForInfo

export type FlowWaitForInfo = {
  executionId: string;
  flowId: string;
  flowRunId: string;
  nodeId: string;
  nodeType: string;
  version: number;
  workspaceId: string;
  data?: Record<string, any>;
};

Flows

export type Flows = {
  activeVersion: number;
  createdAt: string;
  createdBy: string;
  description?: string;
  flow: Flow;
  id: string;
  name: string;
  status: FlowStatus;
  updatedAt: string;
  updatedBy: string;
  versionUpdatedAt: string;
  versionUpdatedBy: string;
  version: number;
  trigger?: TriggerOption;
  triggerActive: boolean;
};

FlowsOption

export type FlowsOption = {
  activeVersion?: number;
  createdAt?: string;
  createdBy?: string;
  description?: string;
  flow?: Flow;
  id?: string;
  name?: string;
  status?: FlowStatus;
  updatedAt?: string;
  updatedBy?: string;
  versionUpdatedAt?: string;
  versionUpdatedBy?: string;
  version?: number;
  trigger?: TriggerOption;
  triggerActive?: boolean;
};

GenerateDataSourceInput

export type GenerateDataSourceInput = { genDsType: GenerateDataSourceType; datasourceId: string };

GenerateDataSourceType

export type GenerateDataSourceType =
  | { type: 'SQL'; data: { sql: string } }
  | { type: 'Table'; data: { tableName: string } }
  | { type: 'External'; data: { extDsId: string; objectName?: string } }
  | { type: 'File'; data: { tableName: string; columns: Array<Column>; csv: string } };

Intake

export type Intake = {
  userNameScript: string;
  reminderUnit: 'Second' | 'Hour' | 'Day';
  reminderFrequency: number;
  timeoutAfterNReminders: number;
  onRequest: string;
  onResponse: string;
};

IntakeEmail

export type IntakeEmail = { subject: string; textBody: string; htmlBody?: string };

IntakeInfo

export type IntakeInfo = {
  executionId: string;
  flowId: string;
  flowRunId: string;
  nodeId: string;
  nodeType: string;
  version: number;
  workspaceId: string;
  userName: string;
};

IntakeQA

export type IntakeQA = { questionItemId: string; answerItemId: string };

IntakeResponse

export type IntakeResponse = {
  executionId: string;
  flowId: string;
  flowRunId: string;
  nodeId: string;
  nodeType: string;
  version: number;
  workspaceId: string;
  userName: string;
  intakeStatus: IntakeResult;
  answers: Record<string, any>;
  intakeFlow: Array<IntakeQA>;
};

IntakeResult

export type IntakeResult = 'Submitted' | 'Timeout' | 'Cancelled' | 'Pending';

IntakeUserInfo

export type IntakeUserInfo = { userName: string; urlState: Record<string, any>; pageId: string; workspaceId: string };

JSError

export type JSError = { code: number; message: string; title: string };

JSRequest

export type JSRequest<T> =
  | { type: 'afterDelete'; data: AfterDeleteInput<T> }
  | { type: 'afterInsert'; data: AfterInsertInput<T> }
  | { type: 'afterUpdate'; data: AfterUpdateInput<T> }
  | { type: 'beforeDelete'; data: BeforeDeleteInput<T> }
  | { type: 'beforeInsert'; data: BeforeInsertInput<T> }
  | { type: 'beforeUpdate'; data: BeforeUpdateInput<T> }
  | { type: 'clearDataSourceCache'; data: string }
  | { type: 'clearExtDataSourceCache'; data: string }
  | { type: 'clearScriptCache'; data: string }
  | { type: 'clearScheduleOnErrorScriptCache'; data: string }
  | { type: 'executeScript'; data: ExecuteScriptInput }
  | { type: 'executeScheduledScript'; data: ExecuteScheduledScriptInput }
  | { type: 'executeScheduleOnErrorScript'; data: ExecuteOnErrorScheduledScriptInput }
  | { type: 'extDescAPI'; data: ExtDescAPIInput }
  | { type: 'extInitAPI'; data: ExtInitAPIInput }
  | { type: 'extPostAPI'; data: ExtPostAPIInput<T> }
  | { type: 'extQueryAPI'; data: ExtQueryAPIInput<T> }
  | { type: 'id'; data: string }
  | { type: 'ping'; data: Array<number> }
  | { type: 'pong'; data: Array<number> }
  | { type: 'postQuery'; data: PostQueryInput<T> }
  | { type: 'preQuery'; data: PreQueryInput<T> }
  | { type: 'validateRow'; data: ValidateRowInput<T> }
  | { type: 'executeDenoNodeScript'; data: ExecuteDenoNodeScriptInput<T> }
  | { type: 'executeDenoNodeExpression'; data: string }
  | { type: 'shutdown' }
  | { type: 'systemFunction'; data: SystemFunctionInput };

JSRequestMessage

export type JSRequestMessage<T> = { id: string; request: JSRequest<T> };

JSResponse

export type JSResponse<T> =
  | { afterDelete: AfterDeleteOutput<T> }
  | { afterInsert: AfterInsertOutput<T> }
  | { afterUpdate: AfterUpdateOutput<T> }
  | { beforeDelete: BeforeDeleteOutput<T> }
  | { beforeInsert: BeforeInsertOutput<T> }
  | { beforeUpdate: BeforeUpdateOutput<T> }
  | 'empty'
  | { error: JSError }
  | { executeScript: ExecuteScriptOutput }
  | { extDescAPI: ExtDescAPIOutput }
  | { extInitAPI: ExtInitAPIOutput }
  | { extPostAPI: ExtPostAPIOutput<T> }
  | { extQueryAPI: ExtQueryAPIOutput<T> }
  | { postQuery: PostQueryOutput<T> }
  | { preQuery: PreQueryOutput<T> }
  | { validateRow: ValidateRowOutput<T> }
  | { executeDenoNodeScript: ExecuteDenoNodeScriptOutput }
  | { executeDenoNodeExpression: any }
  | { systemFunction: SystemFunctionOutput };

JSResponseMessage

export type JSResponseMessage<T> = { id: string; response: string };

JSScriptType

export type JSScriptType =
  | 'AfterDelete'
  | 'AfterInsert'
  | 'AfterUpdate'
  | 'BeforeDelete'
  | 'BeforeInsert'
  | 'BeforeUpdate'
  | 'FlowScript'
  | 'PostQuery'
  | 'PreQuery'
  | 'ScheduleOnError'
  | 'Script'
  | 'ValidateRow'
  | 'ExtQueryAPI'
  | 'ExtPostAPI'
  | 'ExtDescAPI'
  | 'ExtInitAPI';

LogFile

export type LogFile = { fileName: string; logEntries: Array<string> };

MFAInfo

export type MFAInfo = { key: string; code: string };

Manifest

export type Manifest = {
  components: Record<string, unknown>;
  componentSources: Record<string, unknown>;
  dataSources: Record<string, unknown>;
  externalDataSources: Record<string, unknown>;
  scripts: Record<string, unknown>;
  testScripts: Record<string, unknown>;
  images: Record<string, unknown>;
  languages: Record<string, unknown>;
  lookups: Record<string, unknown>;
  pages: Record<string, unknown>;
  profiles: Record<string, unknown>;
  roles: Record<string, unknown>;
  flowNodes: Record<string, unknown>;
  flows: Record<string, unknown>;
  buildDate: string;
  buildVersion: string;
  elapsedMs: number;
  settings: string;
  totalComponentSources: number;
  totalComponents: number;
  totalDataSources: number;
  totalExternalDataSources: number;
  totalScripts: number;
  totalTestScripts: number;
  totalLookups: number;
  totalLanguages: number;
  totalPages: number;
  totalProfiles: number;
  totalRoles: number;
  totalFlowNodes: number;
  totalFlows: number;
  totalImages: number;
  ts: string;
  version: string;
  id: string;
  dbScripts: Record<string, unknown>;
  totalDbScripts: number;
  howTos: Record<string, unknown>;
  totalHowTos: number;
  resources: Record<string, unknown>;
  totalResources: number;
  resourceTypes: Record<string, unknown>;
  totalResourceTypes: number;
  variables: Record<string, unknown>;
  totalVariables: number;
};