@kelta/sdk — API Reference

Every symbol exported from @kelta/sdk, the TypeScript client, with its TypeScript signature and doc summary — generated from the package entry point.

Every symbol exported from @kelta/sdk, with its TypeScript signature and the first paragraph of its doc comment — generated from kelta-web/packages/sdk/src/index.ts. For a guided tour with examples, see @kelta/sdk.

186 exports, grouped by kind and sorted by name.

Classes#

AdminClient#

Admin client for platform operations.

class AdminClient {
    constructor(axios: AxiosInstance);
    readonly collections: {
        list: () => Promise<CollectionDefinition[]>;
        get: (id: string) => Promise<CollectionDefinition>;
        create: (definition: CollectionDefinition) => Promise<CollectionDefinition>;
        update: (id: string, definition: CollectionDefinition) => Promise<CollectionDefinition>;
        delete: (id: string) => Promise<void>;
    };
    readonly fields: {
        add: (collectionId: string, field: FieldDefinition) => Promise<FieldDefinition>;
        update: (_collectionId: string, fieldId: string, field: FieldDefinition) => Promise<FieldDefinition>;
        delete: (_collectionId: string, fieldId: string) => Promise<void>;
    };
    readonly oidc: {
        list: () => Promise<OIDCProvider[]>;
        get: (id: string) => Promise<OIDCProvider>;
        create: (provider: OIDCProvider) => Promise<OIDCProvider>;
        update: (id: string, provider: OIDCProvider) => Promise<OIDCProvider>;
        delete: (id: string) => Promise<void>;
    };
    readonly ui: {
        getBootstrap: () => Promise<UIConfig>;
        listPages: () => Promise<UIPage[]>;
        createPage: (page: UIPage) => Promise<UIPage>;
        updatePage: (id: string, page: UIPage) => Promise<UIPage>;
        listMenus: () => Promise<UIMenu[]>;
        updateMenu: (id: string, menu: UIMenu) => Promise<UIMenu>;
    };
    readonly packages: {
        export: (_options: ExportOptions) => Promise<PackageData>;
        import: (_packageData: PackageData) => Promise<ImportResult>;
    };
    readonly tenants: {
        list: (page?: number, size?: number) => Promise<Page<Tenant>>;
        get: (id: string) => Promise<Tenant>;
        create: (request: CreateTenantRequest) => Promise<Tenant>;
        update: (id: string, request: UpdateTenantRequest) => Promise<Tenant>;
        suspend: (id: string) => Promise<void>;
        activate: (id: string) => Promise<void>;
        inviteAdmin: (id: string, email: string) => Promise<TenantAdminInviteResponse>;
        bootstrapToken: (id: string, request?: TenantBootstrapTokenRequest) => Promise<TenantBootstrapTokenResponse>;
        getLimits: (id: string) => Promise<GovernorLimits>;
    };
    readonly users: {
        list: (filter?: string, status?: string, page?: number, size?: number) => Promise<Page<PlatformUser>>;
        get: (id: string) => Promise<PlatformUser>;
        create: (request: CreatePlatformUserRequest) => Promise<PlatformUser>;
        update: (id: string, request: UpdatePlatformUserRequest) => Promise<PlatformUser>;
        deactivate: (id: string) => Promise<void>;
        activate: (id: string) => Promise<void>;
        invitePortal: (request: PortalInviteRequest) => Promise<PortalInviteResponse>;
        getLoginHistory: (id: string, page?: number, size?: number) => Promise<Page<LoginHistoryEntry>>;
        resetPassword: (userId: string) => Promise<{
            status: string;
            userId: string;
        }>;
        tokens: {
            create: (userId: string, request: CreatePersonalAccessTokenRequest) => Promise<PersonalAccessTokenCreated>;
            list: (userId: string) => Promise<AdminUserPersonalAccessToken[]>;
            revoke: (userId: string, tokenId: string) => Promise<void>;
        };
    };
    readonly delegated: {
        me: () => Promise<DelegatedAdminSummary>;
        users: {
            list: (page?: number, limit?: number) => Promise<PlatformUser[]>;
            create: (request: DelegatedCreateUserRequest) => Promise<PlatformUser>;
            update: (id: string, request: DelegatedUpdateUserRequest) => Promise<PlatformUser>;
            invite: (id: string) => Promise<{
                status: string;
            }>;
            resetPassword: (id: string) => Promise<{
                status: string;
                userId: string;
            }>;
        };
    };
    readonly delegatedAdminScopes: {
        list: (page?: number, limit?: number) => Promise<DelegatedAdminScope[]>;
        get: (id: string) => Promise<DelegatedAdminScope>;
        create: (request: SaveDelegatedAdminScopeRequest) => Promise<DelegatedAdminScope>;
        update: (id: string, request: SaveDelegatedAdminScopeRequest) => Promise<DelegatedAdminScope>;
        delete: (id: string) => Promise<void>;
    };
    readonly picklists: {
        listGlobal: (_tenantId?: string) => Promise<GlobalPicklist[]>;
        createGlobal: (request: CreateGlobalPicklistRequest, _tenantId?: string) => Promise<GlobalPicklist>;
        getGlobal: (id: string) => Promise<GlobalPicklist>;
        updateGlobal: (id: string, request: Partial<CreateGlobalPicklistRequest>) => Promise<GlobalPicklist>;
        deleteGlobal: (id: string) => Promise<void>;
        getGlobalValues: (id: string) => Promise<PicklistValue[]>;
        setGlobalValues: (id: string, values: PicklistValueRequest[]) => Promise<PicklistValue[]>;
        getFieldValues: (fieldId: string) => Promise<PicklistValue[]>;
        setFieldValues: (fieldId: string, values: PicklistValueRequest[]) => Promise<PicklistValue[]>;
        getDependencies: (fieldId: string) => Promise<PicklistDependency[]>;
        setDependency: (request: SetDependencyRequest) => Promise<PicklistDependency>;
        removeDependency: (controllingFieldId: string, dependentFieldId: string) => Promise<void>;
    };
    readonly relationships: {
        getForCollection: (collectionId: string) => Promise<CollectionRelationships>;
    };
    readonly validationRules: {
        list: (collectionId: string) => Promise<CollectionValidationRule[]>;
        create: (collectionId: string, request: CreateCollectionValidationRuleRequest) => Promise<CollectionValidationRule>;
        get: (_collectionId: string, ruleId: string) => Promise<CollectionValidationRule>;
        update: (_collectionId: string, ruleId: string, request: Partial<CreateCollectionValidationRuleRequest> & {
            active?: boolean;
        }) => Promise<CollectionValidationRule>;
        delete: (_collectionId: string, ruleId: string) => Promise<void>;
        activate: (_collectionId: string, ruleId: string) => Promise<void>;
        deactivate: (_collectionId: string, ruleId: string) => Promise<void>;
        test: (_collectionId: string, _testRecord: Record<string, unknown>) => Promise<CollectionValidationError[]>;
    };
    readonly recordTypes: {
        list: (collectionId: string) => Promise<RecordType[]>;
        create: (collectionId: string, request: CreateRecordTypeRequest) => Promise<RecordType>;
        get: (_collectionId: string, recordTypeId: string) => Promise<RecordType>;
        update: (_collectionId: string, recordTypeId: string, request: Partial<CreateRecordTypeRequest> & {
            active?: boolean;
        }) => Promise<RecordType>;
        delete: (_collectionId: string, recordTypeId: string) => Promise<void>;
        getPicklistOverrides: (collectionId: string, recordTypeId: string) => Promise<RecordTypePicklistOverride[]>;
        setPicklistOverride: (collectionId: string, recordTypeId: string, fieldId: string, request: SetPicklistOverrideRequest) => Promise<RecordTypePicklistOverride>;
        removePicklistOverride: (_collectionId: string, _recordTypeId: string, picklistOverrideId: string) => Promise<void>;
    };
    readonly fieldHistory: {
        getRecordHistory: (collectionId: string, recordId: string, page?: number, size?: number) => Promise<Page<FieldHistoryEntry>>;
        getFieldHistory: (collectionId: string, recordId: string, fieldName: string, page?: number, size?: number) => Promise<Page<FieldHistoryEntry>>;
        getFieldHistoryAcrossRecords: (collectionId: string, fieldName: string, page?: number, size?: number) => Promise<Page<FieldHistoryEntry>>;
        getUserHistory: (userId: string, page?: number, size?: number) => Promise<Page<FieldHistoryEntry>>;
    };
    readonly migrations: {
        plan: (_collectionId: string, _targetSchema: CollectionDefinition) => Promise<MigrationPlan>;
        listRuns: () => Promise<Migration[]>;
        getRun: (id: string) => Promise<MigrationRun>;
    };
    readonly profiles: {
        list: () => Promise<Profile[]>;
        get: (id: string) => Promise<Profile>;
        create: (request: CreateProfileRequest) => Promise<Profile>;
        update: (id: string, request: UpdateProfileRequest) => Promise<Profile>;
        delete: (id: string) => Promise<void>;
        setObjectPermissions: (id: string, collectionId: string, perms: ObjectPermissionRequest) => Promise<void>;
        setFieldPermissions: (id: string, perms: FieldPermissionRequest[]) => Promise<void>;
        setSystemPermissions: (id: string, perms: SystemPermissionRequest[]) => Promise<void>;
    };
    readonly sharing: {
        getOwd: (collectionId: string) => Promise<OrgWideDefault>;
        setOwd: (collectionId: string, request: SetOwdRequest) => Promise<OrgWideDefault>;
        listOwds: () => Promise<OrgWideDefault[]>;
        listRules: (collectionId: string) => Promise<SharingRule[]>;
        createRule: (_collectionId: string, request: CreateSharingRuleRequest) => Promise<SharingRule>;
        updateRule: (ruleId: string, request: UpdateSharingRuleRequest) => Promise<SharingRule>;
        deleteRule: (ruleId: string) => Promise<void>;
        listRecordShares: (collectionId: string, recordId: string) => Promise<RecordShare[]>;
    };
    readonly groups: {
        list: () => Promise<UserGroup[]>;
        get: (id: string) => Promise<UserGroup>;
        create: (request: CreateUserGroupRequest) => Promise<UserGroup>;
        updateMembers: (id: string, memberIds: string[]) => Promise<UserGroup>;
        delete: (id: string) => Promise<void>;
    };
    readonly audit: {
        list: (params?: {
            section?: string;
            entityType?: string;
            userId?: string;
            from?: string;
            to?: string;
            page?: number;
            size?: number;
        }) => Promise<Page<SetupAuditTrailEntry>>;
        getEntityHistory: (entityType: string, entityId: string, page?: number, size?: number) => Promise<Page<SetupAuditTrailEntry>>;
    };
    readonly governorLimits: {
        getStatus: () => Promise<GovernorLimitsStatus>;
        updateTier: (tier: "FREE" | "PROFESSIONAL" | "ENTERPRISE" | "UNLIMITED") => Promise<GovernorLimitsStatus>;
    };
    readonly layouts: {
        list: (collectionId: string) => Promise<PageLayout[]>;
        get: (id: string) => Promise<PageLayout>;
        create: (_tenantId: string, request: CreatePageLayoutRequest) => Promise<PageLayout>;
        update: (id: string, request: Partial<CreatePageLayoutRequest>) => Promise<PageLayout>;
        delete: (id: string) => Promise<void>;
        listAssignments: (collectionId: string) => Promise<LayoutAssignment[]>;
        assign: (request: LayoutAssignmentRequest) => Promise<LayoutAssignment>;
        resolve: (collectionId: string, profileId?: string, recordTypeId?: string, record?: Record<string, unknown>) => Promise<PageLayout>;
    };
    readonly layoutRules: {
        list: (layoutId: string) => Promise<LayoutRule[]>;
        get: (id: string) => Promise<LayoutRule>;
        create: (request: CreateLayoutRuleRequest) => Promise<LayoutRule>;
        update: (id: string, request: UpdateLayoutRuleRequest) => Promise<LayoutRule>;
        delete: (id: string) => Promise<void>;
    };
    readonly listViews: {
        list: (_tenantId: string, collectionId: string, _userId?: string) => Promise<ListView[]>;
        get: (id: string) => Promise<ListView>;
        create: (_tenantId: string, _userId: string, request: CreateListViewRequest) => Promise<ListView>;
        update: (id: string, request: Partial<CreateListViewRequest>) => Promise<ListView>;
        delete: (id: string) => Promise<void>;
    };
    readonly reports: {
        list: (_tenantId?: string, _userId?: string) => Promise<Report[]>;
        get: (id: string) => Promise<Report>;
        create: (_tenantId: string, _userId: string, request: CreateReportRequest) => Promise<Report>;
        update: (id: string, request: Partial<CreateReportRequest>) => Promise<Report>;
        delete: (id: string) => Promise<void>;
        listFolders: (_tenantId?: string) => Promise<ReportFolder[]>;
        createFolder: (_tenantId: string, _userId: string, name: string, accessLevel?: string) => Promise<ReportFolder>;
        deleteFolder: (id: string) => Promise<void>;
    };
    readonly dashboards: {
        list: (_tenantId?: string, _userId?: string) => Promise<UserDashboard[]>;
        get: (id: string) => Promise<UserDashboard>;
        create: (_tenantId: string, _userId: string, request: CreateDashboardRequest) => Promise<UserDashboard>;
        update: (id: string, request: Partial<CreateDashboardRequest>) => Promise<UserDashboard>;
        delete: (id: string) => Promise<void>;
    };
    readonly dataExport: {
        exportCsv: (_request: ExportRequest) => Promise<Blob>;
        exportXlsx: (_request: ExportRequest) => Promise<Blob>;
    };
    readonly emailTemplates: {
        list: (_tenantId?: string) => Promise<EmailTemplate[]>;
        get: (id: string) => Promise<EmailTemplate>;
        create: (_tenantId: string, _userId: string, request: CreateEmailTemplateRequest) => Promise<EmailTemplate>;
        update: (id: string, request: Partial<CreateEmailTemplateRequest>) => Promise<EmailTemplate>;
        delete: (id: string) => Promise<void>;
        listLogs: (_tenantId?: string, _status?: string) => Promise<EmailLog[]>;
    };
    readonly campaigns: {
        list: (limit?: number, offset?: number) => Promise<Campaign[]>;
        get: (id: string) => Promise<Campaign>;
        create: (request: CreateCampaignRequest) => Promise<Campaign>;
        update: (id: string, request: Partial<CreateCampaignRequest>) => Promise<Campaign>;
        delete: (id: string) => Promise<void>;
        send: (id: string) => Promise<{
            status: string;
        }>;
        schedule: (id: string, scheduledAt: string) => Promise<{
            status: string;
        }>;
        cancel: (id: string) => Promise<{
            status: string;
        }>;
        stats: (id: string) => Promise<CampaignStats>;
        recipients: (id: string, limit?: number, offset?: number) => Promise<CampaignRecipient[]>;
        test: (id: string, email: string) => Promise<void>;
        listSuppressions: (limit?: number, offset?: number) => Promise<EmailSuppression[]>;
        addSuppression: (email: string, reason?: string) => Promise<EmailSuppression>;
        removeSuppression: (email: string) => Promise<void>;
    };
    readonly approvals: {
        listProcesses: (_tenantId?: string) => Promise<ApprovalProcess[]>;
        getProcess: (id: string) => Promise<ApprovalProcess>;
        createProcess: (_tenantId: string, request: CreateApprovalProcessRequest) => Promise<ApprovalProcess>;
        updateProcess: (id: string, request: Partial<CreateApprovalProcessRequest>) => Promise<ApprovalProcess>;
        deleteProcess: (id: string) => Promise<void>;
        listInstances: (_tenantId: string) => Promise<ApprovalInstance[]>;
        getPendingForUser: (userId: string) => Promise<ApprovalInstance[]>;
    };
    readonly flows: {
        list: (_tenantId?: string) => Promise<FlowDefinition[]>;
        get: (id: string) => Promise<FlowDefinition>;
        create: (_tenantId: string, _userId: string, request: CreateFlowRequest) => Promise<FlowDefinition>;
        update: (id: string, request: Partial<CreateFlowRequest>) => Promise<FlowDefinition>;
        delete: (id: string) => Promise<void>;
        listExecutions: (_tenantId?: string) => Promise<FlowExecution[]>;
        getExecution: (executionId: string) => Promise<FlowExecution>;
        getWebhookUrl: (flowId: string) => Promise<WebhookUrlResponse>;
    };
    readonly scheduledJobs: {
        list: (_tenantId?: string) => Promise<ScheduledJob[]>;
        get: (id: string) => Promise<ScheduledJob>;
        create: (_tenantId: string, _userId: string, request: CreateScheduledJobRequest) => Promise<ScheduledJob>;
        update: (id: string, request: Partial<CreateScheduledJobRequest>) => Promise<ScheduledJob>;
        delete: (id: string) => Promise<void>;
        listLogs: (id: string) => Promise<JobExecutionLog[]>;
        pause: (id: string) => Promise<void>;
        resume: (id: string) => Promise<void>;
        execute: (id: string) => Promise<void>;
    };
    readonly scripts: {
        list: (_tenantId?: string) => Promise<Script[]>;
        get: (id: string) => Promise<Script>;
        create: (_tenantId: string, _userId: string, request: CreateScriptRequest) => Promise<Script>;
        update: (id: string, request: Partial<CreateScriptRequest>) => Promise<Script>;
        delete: (id: string) => Promise<void>;
        listLogs: (_tenantId?: string) => Promise<ScriptExecutionLog[]>;
        listLogsByScript: (id: string) => Promise<ScriptExecutionLog[]>;
    };
    readonly svix: {
        getPortalAccess: () => Promise<SvixPortalResponse>;
    };
    readonly superset: {
        getGuestToken: (dashboardId: string) => Promise<SupersetGuestTokenResponse>;
        listDashboards: () => Promise<SupersetDashboard[]>;
        listDatasets: () => Promise<SupersetDataset[]>;
        syncDatasets: () => Promise<void>;
    };
    readonly connectedApps: {
        list: (_tenantId?: string) => Promise<ConnectedApp[]>;
        get: (id: string) => Promise<ConnectedApp>;
        create: (_tenantId: string, _userId: string, request: CreateConnectedAppRequest) => Promise<ConnectedAppCreatedResponse>;
        update: (id: string, request: Partial<CreateConnectedAppRequest>) => Promise<ConnectedApp>;
        delete: (id: string) => Promise<void>;
        rotateSecret: (_id: string) => Promise<ConnectedAppCreatedResponse>;
        listTokens: (id: string) => Promise<ConnectedAppToken[]>;
        generateToken: (id: string) => Promise<Record<string, string>>;
        revokeToken: (appId: string, tokenId: string) => Promise<void>;
        listAudit: (id: string) => Promise<Record<string, unknown>[]>;
    };
    readonly credentials: {
        list: () => Promise<Record<string, unknown>[]>;
        get: (id: string) => Promise<Record<string, unknown>>;
        create: (record: Record<string, unknown>) => Promise<Record<string, unknown>>;
        update: (id: string, record: Record<string, unknown>) => Promise<Record<string, unknown>>;
        delete: (id: string) => Promise<void>;
        types: () => Promise<CredentialTypeDescriptor[]>;
        templates: () => Promise<CredentialTemplateDescriptor[]>;
        test: (id: string) => Promise<CredentialTestResultPayload>;
        testInline: (type: string, data: Record<string, unknown>) => Promise<CredentialTestResultPayload>;
        beginOAuth: (id: string) => Promise<{
            authUrl: string;
            state: string;
            expiresInSeconds: number;
        }>;
        completeOAuth: (state: string, code: string, redirectUri?: string) => Promise<{
            ok: boolean;
            expiresAt?: string;
            scope?: string;
        }>;
    };
    readonly apiSpecs: {
        list: () => Promise<ApiSpecSummary[]>;
        get: (id: string) => Promise<ApiSpecSummary>;
        raw: (id: string) => Promise<string>;
        importSpec: (request: ImportApiSpecRequest) => Promise<ImportApiSpecResponse>;
        validate: (request: {
            raw?: string;
            sourceUrl?: string;
        }) => Promise<ApiSpecValidateResult>;
        delete: (id: string) => Promise<void>;
        listOperations: (specId: string) => Promise<ApiOperationSummary[]>;
        getOperation: (specId: string, opId: string) => Promise<ApiOperationDetail>;
        searchOperations: (params: {
            q?: string;
            method?: string;
            specId?: string;
            limit?: number;
        }) => Promise<ApiOperationSummary[]>;
    };
    readonly passwordPolicy: {
        get: () => Promise<Record<string, unknown>>;
        update: (policy: Record<string, unknown>) => Promise<void>;
        unlockUser: (userId: string) => Promise<void>;
    };
    readonly emailSettings: {
        get: () => Promise<EmailSettings>;
        update: (update: EmailSettingsUpdate) => Promise<void>;
        testSend: (to: string) => Promise<void>;
    };
    readonly emailTemplateOverrides: {
        list: () => Promise<EmailTemplateEntry[]>;
        override: (templateKey: string) => Promise<void>;
        revert: (templateKey: string) => Promise<void>;
        inviteUser: (userId: string) => Promise<void>;
    };
    readonly bulkJobs: {
        list: (_tenantId?: string) => Promise<BulkJob[]>;
        get: (id: string) => Promise<BulkJob>;
        create: (_tenantId: string, _userId: string, request: CreateBulkJobRequest) => Promise<BulkJob>;
        abort: (id: string) => Promise<BulkJob>;
        getResults: (id: string) => Promise<BulkJobResult[]>;
        getErrors: (id: string) => Promise<BulkJobResult[]>;
    };
    readonly composite: {
        execute: (_tenantId: string, _request: CompositeRequest) => Promise<CompositeResponse>;
    };
    readonly metrics: {
        query: (params: MetricsQueryParams) => Promise<MetricsQueryResult>;
        summary: () => Promise<MetricsSummary>;
        endpoints: (limit?: number) => Promise<{
            endpoints: EndpointPerformance[];
        }>;
        errors: (limit?: number) => Promise<{
            errors: ErrorGroup[];
        }>;
        latency: (start?: string, end?: string) => Promise<LatencyPercentiles>;
    };
    readonly observability: {
        searchRequestLogs: (params: RequestLogSearchParams) => Promise<RequestLogSearchResult>;
        getRequestLog: (traceId: string) => Promise<RequestLogDetail>;
        searchLogs: (params: LogSearchParams) => Promise<LogSearchResult>;
        searchAudit: (params: AuditSearchParams) => Promise<AuditSearchResult>;
        getSettings: () => Promise<ObservabilitySettingsResponse>;
        updateSettings: (request: UpdateObservabilitySettingsRequest) => Promise<ObservabilitySettingsResponse>;
    };
    readonly searchReindex: {
        getStats: () => Promise<SearchIndexStats>;
        reindex: (collectionName?: string) => Promise<SearchReindexResult>;
    };
    readonly mfa: {
        getUserStatus: (userId: string) => Promise<{
            userId: string;
            mfaEnabled: boolean;
            enrolled: boolean;
            enrolledAt: string | null;
            remainingRecoveryCodes: number;
        }>;
        resetUser: (userId: string) => Promise<{
            status: string;
            userId: string;
        }>;
        getPolicy: () => Promise<{
            mfaRequired: boolean;
        }>;
        updatePolicy: (policy: {
            mfaRequired: boolean;
        }) => Promise<{
            status: string;
        }>;
    };
    readonly personalTokens: {
        list: () => Promise<PersonalAccessToken[]>;
        create: (request: CreatePersonalAccessTokenRequest) => Promise<PersonalAccessTokenCreated>;
        revoke: (tokenId: string) => Promise<void>;
    };
    readonly ai: {
        chat: (request: AiChatRequest) => Promise<AiChatResponse>;
        chatStream: (request: AiChatRequest) => ReadableStream;
        conversations: () => Promise<AiConversationSummary[]>;
        conversation: (id: string) => Promise<AiConversationDetail>;
        applyProposal: (proposalId: string) => Promise<AiApplyResult>;
        usage: () => Promise<AiTokenUsage>;
        config: {
            get: () => Promise<AiConfig>;
            update: (config: Partial<AiConfig>) => Promise<AiConfig>;
        };
    };
}

AuthenticationError#

Authentication error (HTTP 401)

class AuthenticationError extends KeltaError {
    constructor(message?: string);
}

AuthorizationError#

Authorization error (HTTP 403)

class AuthorizationError extends KeltaError {
    constructor(message?: string);
}

KeltaClient#

Main Kelta client for interacting with Kelta services

class KeltaClient {
    constructor(config: KeltaClientConfig);
    readonly admin: AdminClient;
    getBaseUrl(): string;
    getAxiosInstance(): AxiosInstance;
    isValidationEnabled(): boolean;
    discover(): Promise<ResourceMetadata[]>;
    resource<T = unknown>(name: string): ResourceClient<T>;
    buildUrl(endpoint: string): string;
    clearDiscoveryCache(): void;
}

KeltaError#

Base error class for all Kelta errors

class KeltaError extends Error {
    constructor(message: string, statusCode?: number | undefined, details?: unknown);
}

NetworkError#

Network error (connection failures, timeouts)

class NetworkError extends KeltaError {
    constructor(message: string, originalError: Error);
}

NotFoundError#

Not found error (HTTP 404)

class NotFoundError extends KeltaError {
    constructor(resource: string, id: string);
}

QueryBuilder#

Fluent query builder for constructing resource queries

class QueryBuilder<T = unknown> {
    constructor(resourceClient: ResourceClient<T>);
    paginate(page: number, size: number): QueryBuilder<T>;
    sort(field: string, direction: "asc" | "desc"): QueryBuilder<T>;
    filter(field: string, operator: FilterExpression["operator"], value: unknown): QueryBuilder<T>;
    fields(...fieldNames: string[]): QueryBuilder<T>;
    include(...relationships: string[]): QueryBuilder<T>;
    buildOptions(): ListOptions;
    buildQueryParams(): string;
    execute(): Promise<ListResponse<T>>;
    reset(): QueryBuilder<T>;
}

ResourceClient#

Client for performing CRUD operations on a specific resource

class ResourceClient<T = unknown> {
    constructor(client: KeltaClient, resourceName: string);
    getName(): string;
    list(options?: ListOptions): Promise<ListResponse<T>>;
    get(id: string, options?: GetOptions): Promise<T>;
    create(data: Partial<T>): Promise<T>;
    update(id: string, data: T): Promise<T>;
    patch(id: string, data: Partial<T>): Promise<T>;
    delete(id: string): Promise<void>;
    listChildren<C = unknown>(parentId: string, childResource: string, options?: ListOptions): Promise<ListResponse<C>>;
    getChild<C = unknown>(parentId: string, childResource: string, childId: string): Promise<C>;
    query(): QueryBuilder<T>;
    buildQueryParams(options?: ListOptions): Record<string, string | string[]>;
    buildListUrl(options?: ListOptions): string;
}

ServerError#

Server error (HTTP 5xx)

class ServerError extends KeltaError {
    constructor(message: string, statusCode?: number);
}

TokenManager#

Manages authentication tokens with automatic refresh

class TokenManager {
    constructor(provider: TokenProvider);
    getValidToken(): Promise<string | null>;
    clearToken(): void;
}

ValidationError#

Validation error (HTTP 400)

class ValidationError extends KeltaError {
    constructor(message: string, fieldErrors?: Record<string, string[]>);
}

Functions#

generateTypes#

Generate all types from an OpenAPI spec

function generateTypes(spec: OpenAPISpec, options?: {
    includeRequests?: boolean;
    includeResponses?: boolean;
}): string;

generateTypesFromSpec#

Generate types from an already-loaded spec object

function generateTypesFromSpec(spec: unknown, outputPath: string, options?: {
    includeRequests?: boolean;
    includeResponses?: boolean;
}): {
    content: string;
    result: TypeGenerationResult;
};

generateTypesFromUrl#

Programmatic API for type generation

function generateTypesFromUrl(url: string, outputPath: string, options?: {
    includeRequests?: boolean;
    includeResponses?: boolean;
}): Promise<TypeGenerationResult>;

parseCollections#

Parse OpenAPI spec to extract collection schemas

function parseCollections(spec: OpenAPISpec): ParsedCollection[];

validateOpenAPISpec#

Validate OpenAPI spec structure

function validateOpenAPISpec(spec: unknown): {
    valid: boolean;
    errors: string[];
};

Constants#

ErrorResponseSchema#

Error response schema

const ErrorResponseSchema: z.ZodObject<{
    error: z.ZodOptional<z.ZodString>;
    message: z.ZodString;
    details: z.ZodOptional<z.ZodUnknown>;
    fieldErrors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
}, z.core.$strip>;

ListResponseSchema#

Generic list response schema factory

const ListResponseSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
    data: z.ZodArray<T>;
    pagination: z.ZodObject<{
        page: z.ZodNumber;
        size: z.ZodNumber;
        total: z.ZodNumber;
        totalPages: z.ZodNumber;
    }, z.core.$strip>;
}, z.core.$strip>;

ResourceMetadataSchema#

Resource metadata schema

const ResourceMetadataSchema: z.ZodObject<{
    name: z.ZodString;
    displayName: z.ZodString;
    fields: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        type: z.ZodEnum<{
            string: "string";
            number: "number";
            boolean: "boolean";
            date: "date";
            datetime: "datetime";
            json: "json";
            reference: "reference";
            picklist: "picklist";
            multi_picklist: "multi_picklist";
            currency: "currency";
            percent: "percent";
            auto_number: "auto_number";
            phone: "phone";
            email: "email";
            url: "url";
            rich_text: "rich_text";
            encrypted: "encrypted";
            external_id: "external_id";
            geolocation: "geolocation";
            lookup: "lookup";
            master_detail: "master_detail";
            formula: "formula";
            rollup_summary: "rollup_summary";
        }>;
        displayName: z.ZodOptional<z.ZodString>;
        required: z.ZodOptional<z.ZodBoolean>;
        unique: z.ZodOptional<z.ZodBoolean>;
        validation: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                email: "email";
                url: "url";
                custom: "custom";
                min: "min";
                max: "max";
                pattern: "pattern";
            }>;
            value: z.ZodOptional<z.ZodUnknown>;
            message: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        defaultValue: z.ZodOptional<z.ZodUnknown>;
        referenceTarget: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    operations: z.ZodArray<z.ZodString>;
    authz: z.ZodOptional<z.ZodObject<{
        read: z.ZodOptional<z.ZodArray<z.ZodString>>;
        create: z.ZodOptional<z.ZodArray<z.ZodString>>;
        update: z.ZodOptional<z.ZodArray<z.ZodString>>;
        delete: z.ZodOptional<z.ZodArray<z.ZodString>>;
        fieldLevel: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
    }, z.core.$strip>>;
}, z.core.$strip>;

Interfaces#

AdminUserPersonalAccessToken#

A managed user’s live token as an admin sees it (GET /api/admin/users/{id}/tokens).

interface AdminUserPersonalAccessToken {
    id: string;
    name: string;
    tokenPrefix: string;
    scopes: string[];
    createdAt: string;
    expiresAt: string;
}

ApiOperationDetail#

interface ApiOperationDetail extends ApiOperationSummary {
    description?: string | null;
    parametersSchema?: unknown;
    requestBodySchema?: unknown;
    responseSchemas?: unknown;
    securityRequired?: unknown;
}

ApiOperationSummary#

interface ApiOperationSummary {
    id: string;
    specId: string;
    operationId?: string | null;
    syntheticOpId: string;
    httpMethod: string;
    pathTemplate: string;
    summary?: string | null;
    tags?: unknown;
    deprecated: boolean;
}

ApiSpecSummary#

interface ApiSpecSummary {
    id: string;
    name: string;
    description?: string | null;
    specVersion: string;
    apiTitle?: string | null;
    apiVersion?: string | null;
    baseUrl?: string | null;
    servers?: unknown;
    securitySchemes?: unknown;
    sourceType: "INLINE_JSON" | "INLINE_YAML" | "URL";
    sourceUrl?: string | null;
    revision: number;
    active: boolean;
    lastImportedAt?: string | null;
}

ApiSpecValidateResult#

interface ApiSpecValidateResult {
    ok: boolean;
    title?: string;
    version?: string;
    specVersion?: string;
    operations?: number;
    baseUrl?: string;
    error?: string;
}

ApprovalInstance#

interface ApprovalInstance {
    id: string;
    approvalProcessId: string;
    approvalProcessName: string;
    collectionId: string;
    recordId: string;
    submittedBy: string;
    currentStepNumber: number;
    status: "PENDING" | "APPROVED" | "REJECTED" | "RECALLED";
    submittedAt: string;
    completedAt?: string;
    stepInstances: ApprovalStepInstance[];
}

ApprovalProcess#

interface ApprovalProcess {
    id: string;
    collectionId: string;
    name: string;
    description?: string;
    active: boolean;
    entryCriteria?: string;
    recordEditability: "LOCKED" | "ADMIN_ONLY";
    initialSubmitterField?: string;
    onSubmitFieldUpdates: string;
    onApprovalFieldUpdates: string;
    onRejectionFieldUpdates: string;
    onRecallFieldUpdates: string;
    allowRecall: boolean;
    executionOrder: number;
    steps: ApprovalStep[];
    createdAt: string;
    updatedAt: string;
}

AuthzConfig#

Authorization configuration for a resource

interface AuthzConfig {
    read?: string[];
    create?: string[];
    update?: string[];
    delete?: string[];
    fieldLevel?: Record<string, string[]>;
}

BulkJob#

interface BulkJob {
    id: string;
    tenantId: string;
    collectionId: string;
    operation: "INSERT" | "UPDATE" | "UPSERT" | "DELETE";
    status: "QUEUED" | "PROCESSING" | "COMPLETED" | "FAILED" | "ABORTED";
    totalRecords: number;
    processedRecords: number;
    successRecords: number;
    errorRecords: number;
    externalIdField?: string;
    contentType: string;
    batchSize: number;
    createdBy: string;
    startedAt?: string;
    completedAt?: string;
    createdAt: string;
    updatedAt: string;
}

BulkJobResult#

interface BulkJobResult {
    id: string;
    bulkJobId: string;
    recordIndex: number;
    recordId?: string;
    status: "SUCCESS" | "FAILURE";
    errorMessage?: string;
    createdAt: string;
}

CacheConfig#

Cache configuration options

interface CacheConfig {
    discoveryTTL?: number;
}

Campaign#

interface Campaign {
    id: string;
    name: string;
    description?: string;
    subject: string;
    bodyHtml?: string;
    templateId?: string;
    targetCollection: string;
    recipientEmailField: string;
    filterJson?: CampaignFilterCondition[];
    listViewId?: string;
    fromName?: string;
    fromAddress?: string;
    status: CampaignStatus;
    scheduledAt?: string;
    totalRecipients?: number;
    sentCount?: number;
    failedCount?: number;
    openCount?: number;
    clickCount?: number;
    unsubscribeCount?: number;
    startedAt?: string;
    completedAt?: string;
    errorMessage?: string;
    createdAt: string;
}

CampaignFilterCondition#

A single filter condition applied to the target collection.

interface CampaignFilterCondition {
    field: string;
    op: string;
    value: unknown;
}

CampaignRecipient#

interface CampaignRecipient {
    id: string;
    campaignId?: string;
    recordId?: string;
    email: string;
    status: string;
    errorMessage?: string;
    sentAt?: string;
    openedAt?: string;
    clickedAt?: string;
}

CampaignStats#

interface CampaignStats {
    status: CampaignStatus;
    totalRecipients: number;
    sent: number;
    failed: number;
    opens: number;
    clicks: number;
    unsubscribes: number;
    startedAt?: string;
    completedAt?: string;
}

CollectionDefinition#

Collection definition for admin operations

interface CollectionDefinition {
    id?: string;
    name: string;
    displayName: string;
    description?: string;
    active?: boolean;
    systemCollection?: boolean;
    currentVersion?: number;
    fields?: FieldDefinition[];
    authz?: AuthzConfig;
    createdAt?: string;
    updatedAt?: string;
}

CollectionRelationships#

All relationships for a collection

interface CollectionRelationships {
    collectionId: string;
    collectionName: string;
    outgoing: RelationshipInfo[];
    incoming: RelationshipInfo[];
}

CollectionValidationError#

Validation error returned when a record fails validation

interface CollectionValidationError {
    ruleName: string;
    errorMessage: string;
    errorField?: string;
}

CollectionValidationRule#

Collection-level validation rule using formula evaluation

interface CollectionValidationRule {
    id: string;
    collectionId: string;
    name: string;
    description?: string;
    active: boolean;
    errorConditionFormula: string;
    errorMessage: string;
    errorField?: string;
    evaluateOn: "CREATE" | "UPDATE" | "CREATE_AND_UPDATE";
    enforceOnClient: boolean;
    severity: "ERROR" | "WARNING";
    createdAt: string;
    updatedAt: string;
}

ComputeLayoutRule#

interface ComputeLayoutRule extends BaseLayoutRule {
    kind: "compute";
    target: string;
    formula: string;
}

ConnectedApp#

interface ConnectedApp {
    id: string;
    tenantId: string;
    name: string;
    description?: string;
    clientId: string;
    redirectUris?: string;
    scopes?: string;
    ipRestrictions?: string;
    rateLimitPerHour: number;
    active: boolean;
    grantTypes?: string[];
    requirePkce?: boolean;
    consentRequired?: boolean;
    lastUsedAt?: string;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}

ConnectedAppCreatedResponse#

interface ConnectedAppCreatedResponse extends ConnectedApp {
    clientSecret: string;
}

CreateApprovalProcessRequest#

interface CreateApprovalProcessRequest {
    collectionId: string;
    name: string;
    description?: string;
    active?: boolean;
    entryCriteria?: string;
    recordEditability?: string;
    initialSubmitterField?: string;
    onSubmitFieldUpdates?: string;
    onApprovalFieldUpdates?: string;
    onRejectionFieldUpdates?: string;
    onRecallFieldUpdates?: string;
    allowRecall?: boolean;
    executionOrder?: number;
    steps?: CreateApprovalStepRequest[];
}

CreateBulkJobRequest#

interface CreateBulkJobRequest {
    collectionId: string;
    operation: string;
    externalIdField?: string;
    batchSize?: number;
    records: Record<string, unknown>[];
}

CreateCampaignRequest#

interface CreateCampaignRequest {
    name: string;
    description?: string;
    subject: string;
    bodyHtml?: string;
    templateId?: string;
    targetCollection: string;
    recipientEmailField: string;
    filterJson?: CampaignFilterCondition[];
    listViewId?: string;
    fromName?: string;
    fromAddress?: string;
    status?: CampaignStatus;
    scheduledAt?: string;
}

CreateCollectionValidationRuleRequest#

Request to create a collection validation rule

interface CreateCollectionValidationRuleRequest {
    name: string;
    description?: string;
    errorConditionFormula: string;
    errorMessage: string;
    errorField?: string;
    evaluateOn?: "CREATE" | "UPDATE" | "CREATE_AND_UPDATE";
    enforceOnClient?: boolean;
    severity?: "ERROR" | "WARNING";
}

CreateConnectedAppRequest#

interface CreateConnectedAppRequest {
    name: string;
    description?: string;
    redirectUris?: string;
    scopes?: string;
    ipRestrictions?: string;
    rateLimitPerHour?: number;
    active?: boolean;
    grantTypes?: string;
    requirePkce?: boolean;
    consentRequired?: boolean;
}

CreateDashboardRequest#

interface CreateDashboardRequest {
    name: string;
    description?: string;
    folderId?: string;
    accessLevel?: string;
    dynamic?: boolean;
    runningUserId?: string;
    columnCount?: number;
    components?: CreateDashboardComponentRequest[];
}

CreateEmailTemplateRequest#

interface CreateEmailTemplateRequest {
    name: string;
    description?: string;
    subject: string;
    bodyHtml: string;
    bodyText?: string;
    relatedCollectionId?: string;
    folder?: string;
    active?: boolean;
}

CreateFieldPlacementRequest#

interface CreateFieldPlacementRequest {
    fieldId: string;
    columnNumber?: number;
    columnSpan?: number;
    sortOrder: number;
    requiredOnLayout?: boolean;
    readOnlyOnLayout?: boolean;
    labelOverride?: string;
    helpTextOverride?: string;
    visibilityRule?: string;
}

CreateFlowRequest#

interface CreateFlowRequest {
    name: string;
    description?: string | null;
    flowType: string;
    active?: boolean;
    triggerConfig?: JsonObjectField | string | null;
    definition: JsonObjectField | string;
    runAsUserId?: string | null;
    stepLogging?: "FULL" | "ERRORS_ONLY" | "NONE";
    retentionDays?: number | null;
}

CreateGlobalPicklistRequest#

Request to create a global picklist

interface CreateGlobalPicklistRequest {
    name: string;
    description?: string;
    sorted?: boolean;
    restricted?: boolean;
    values?: PicklistValueRequest[];
}

CreateLayoutRuleRequest#

interface CreateLayoutRuleRequest {
    layoutId: string;
    name: string;
    description?: string;
    kind: "COMPUTE" | "VALIDATE" | "DEFAULT" | "TRANSFORM" | "SCRIPT";
    active?: boolean;
    whenEvents: LayoutRuleEvent[];
    targetField?: string;
    dependsOn?: string[];
    body: Record<string, unknown>;
    sortOrder: number;
}

CreateLayoutSectionRequest#

interface CreateLayoutSectionRequest {
    heading: string;
    columns?: number;
    sortOrder: number;
    collapsed?: boolean;
    style?: string;
    sectionType?: string;
    tabGroup?: string;
    tabLabel?: string;
    visibilityRule?: string;
    fields?: CreateFieldPlacementRequest[];
}

CreateListViewRequest#

interface CreateListViewRequest {
    collectionId: string;
    name: string;
    columns: string;
    filters?: string;
    filterLogic?: string;
    sortField?: string;
    sortDirection?: string;
    chartConfig?: string;
    visibility?: string;
    viewType?: ListViewType;
    typeConfig?: ListViewTypeConfig | null;
}

CreatePageLayoutRequest#

interface CreatePageLayoutRequest {
    collectionId: string;
    name: string;
    description?: string;
    layoutType: string;
    isDefault?: boolean;
    sections?: CreateLayoutSectionRequest[];
    relatedLists?: CreateRelatedListRequest[];
    defaultFilter?: LayoutFilter | null;
    defaultSortField?: string;
    defaultSortDirection?: "ASC" | "DESC";
    defaultRowLimit?: number;
}

CreatePersonalAccessTokenRequest#

interface CreatePersonalAccessTokenRequest {
    name: string;
    scopes?: string[];
    expiresInDays?: number;
}

CreatePlatformUserRequest#

Request to create a user

interface CreatePlatformUserRequest {
    email: string;
    firstName: string;
    lastName: string;
    username?: string;
    locale?: string;
    timezone?: string;
    profileId?: string;
}

CreateProfileRequest#

Request to create a profile

interface CreateProfileRequest {
    name: string;
    description?: string;
}

CreateRecordTypeRequest#

Request to create a record type

interface CreateRecordTypeRequest {
    name: string;
    description?: string;
    isDefault?: boolean;
    isActive?: boolean;
}

CreateRelatedListRequest#

interface CreateRelatedListRequest {
    relatedCollectionId: string;
    relationshipField: string;
    displayColumns?: string;
    sortField?: string;
    sortDirection?: string;
    rowLimit?: number;
    sortOrder: number;
}

CreateReportRequest#

interface CreateReportRequest {
    name: string;
    description?: string;
    reportType: string;
    primaryCollectionId: string;
    relatedJoins?: string;
    columns: string;
    filters?: string;
    filterLogic?: string;
    rowGroupings?: string;
    columnGroupings?: string;
    sortOrder?: string;
    chartType?: string;
    chartConfig?: string;
    scope?: string;
    folderId?: string;
    accessLevel?: string;
}

CreateScheduledJobRequest#

interface CreateScheduledJobRequest {
    name: string;
    description?: string;
    jobType: string;
    jobReferenceId?: string;
    cronExpression: string;
    timezone?: string;
    active?: boolean;
}

CreateScriptRequest#

interface CreateScriptRequest {
    name: string;
    description?: string;
    scriptType: string;
    language?: string;
    sourceCode: string;
    active?: boolean;
    triggers?: CreateScriptTriggerRequest[];
}

CreateTenantRequest#

Request to create a tenant

interface CreateTenantRequest {
    slug: string;
    name: string;
    edition?: string;
    settings?: Record<string, unknown>;
    limits?: Partial<GovernorLimits>;
    adminEmail?: string;
}

CredentialRecord#

interface CredentialRecord {
    id: string;
    name: string;
    displayName?: string;
    description?: string;
    type: string;
    providerTemplate?: string;
    metadata?: Record<string, unknown>;
    active: boolean;
    lastTestAt?: string;
    lastTestStatus?: string;
    lastTestError?: string;
    createdAt?: string;
    updatedAt?: string;
}

CredentialTemplateDescriptor#

interface CredentialTemplateDescriptor {
    key: string;
    name: string;
    type: string;
    iconUrl?: string;
    defaults?: Record<string, unknown>;
}

CredentialTestResultPayload#

interface CredentialTestResultPayload {
    ok: boolean;
    message: string;
    details?: Record<string, unknown>;
}

CredentialTypeDescriptor#

interface CredentialTypeDescriptor {
    key: string;
    displayName: string;
    description: string;
    inputSchema: Record<string, unknown>;
    supportsOAuthRefresh: boolean;
}

DefaultLayoutRule#

interface DefaultLayoutRule extends BaseLayoutRule {
    kind: "default";
    target: string;
    formula: string;
    triggerFields?: string[];
}

DelegatedAdminScope#

A delegated-admin scope definition (delegated-admin-scopes system collection).

interface DelegatedAdminScope {
    id: string;
    name: string;
    description?: string;
    active: boolean;
    delegatedUserIds: string[];
    manageableProfileIds: string[];
    canCreateUsers: boolean;
    canDeactivateUsers: boolean;
    canResetPasswords: boolean;
    createdAt?: string;
    updatedAt?: string;
}

DelegatedAdminSummary#

The caller’s effective delegated-administration summary (GET /api/admin/delegated/me).

interface DelegatedAdminSummary {
    delegated: boolean;
    canCreateUsers: boolean;
    canDeactivateUsers: boolean;
    canResetPasswords: boolean;
    manageableProfiles: DelegatedNamedRef[];
}

DelegatedCreateUserRequest#

Create payload for a delegated user create (status is forced server-side).

interface DelegatedCreateUserRequest {
    email: string;
    firstName?: string;
    lastName?: string;
    username?: string;
    locale?: string;
    timezone?: string;
    profileId: string;
}

DelegatedNamedRef#

A named reference (id + display name) inside a delegated-admin summary.

interface DelegatedNamedRef {
    id: string;
    name: string;
}

DelegatedUpdateUserRequest#

Update payload for a delegated user update (whitelisted fields only).

interface DelegatedUpdateUserRequest {
    firstName?: string;
    lastName?: string;
    username?: string;
    locale?: string;
    timezone?: string;
    profileId?: string;
    status?: "ACTIVE" | "INACTIVE";
}

EmailLog#

interface EmailLog {
    id: string;
    templateId?: string;
    recipientEmail: string;
    subject: string;
    status: "QUEUED" | "SENT" | "FAILED";
    source?: string;
    sourceId?: string;
    errorMessage?: string;
    sentAt?: string;
    createdAt: string;
}

EmailSuppression#

interface EmailSuppression {
    id: string;
    email: string;
    reason?: string;
    createdAt?: string;
}

EmailTemplate#

interface EmailTemplate {
    id: string;
    name: string;
    description?: string;
    subject: string;
    bodyHtml: string;
    bodyText?: string;
    relatedCollectionId?: string;
    folder?: string;
    active: boolean;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}

ExportOptions#

Export options

interface ExportOptions {
    includeCollections?: string[];
    includeRoles?: boolean;
    includePolicies?: boolean;
    includeUIConfig?: boolean;
}

FieldDefinition#

Field definition

interface FieldDefinition {
    id?: string;
    collectionId?: string;
    name: string;
    displayName?: string;
    type: FieldType;
    required?: boolean;
    unique?: boolean;
    indexed?: boolean;
    defaultValue?: string;
    referenceTarget?: string;
    fieldTypeConfig?: FieldTypeConfig;
    order?: number;
    active?: boolean;
    description?: string;
    constraints?: string;
    validation?: ValidationRule[];
    relationshipType?: "LOOKUP" | "MASTER_DETAIL";
    relationshipName?: string;
    cascadeDelete?: boolean;
    referenceCollectionId?: string;
    createdAt?: string;
    updatedAt?: string;
}

FieldHistoryEntry#

Field history entry tracking a single field change

interface FieldHistoryEntry {
    id: string;
    collectionId: string;
    recordId: string;
    fieldName: string;
    oldValue: unknown;
    newValue: unknown;
    changedBy: string;
    changedAt: string;
    changeSource: "UI" | "API" | "WORKFLOW" | "SYSTEM" | "IMPORT";
}

FieldPermissionRequest#

Request to set field permissions

interface FieldPermissionRequest {
    fieldId: string;
    visibility: "VISIBLE" | "READ_ONLY" | "HIDDEN";
}

FieldTypeConfig#

Type-specific configuration for fields

interface FieldTypeConfig {
    globalPicklistId?: string;
    prefix?: string;
    padding?: number;
    precision?: number;
    defaultCurrencyCode?: string;
    expression?: string;
    returnType?: string;
    childCollection?: string;
    aggregateFunction?: "COUNT" | "SUM" | "MIN" | "MAX" | "AVG";
    aggregateField?: string;
    latitude?: number;
    longitude?: number;
    targetCollection?: string;
    relationshipName?: string;
}

FilterExpression#

Filter expression for list operations

interface FilterExpression {
    field: string;
    operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "isnull" | "contains" | "starts" | "ends" | "icontains" | "istarts" | "iends" | "ieq" | "in";
    value: unknown;
}

FlowDefinition#

interface FlowDefinition {
    id: string;
    name: string;
    description?: string;
    flowType: "RECORD_TRIGGERED" | "SCHEDULED" | "AUTOLAUNCHED" | "SCREEN";
    active: boolean;
    version: number;
    triggerConfig?: string;
    definition: string;
    stepLogging?: "FULL" | "ERRORS_ONLY" | "NONE";
    retentionDays?: number | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}

FlowExecution#

interface FlowExecution {
    id: string;
    flowId: string;
    flowName: string;
    status: "RUNNING" | "COMPLETED" | "FAILED" | "WAITING" | "CANCELLED";
    startedBy?: string;
    triggerRecordId?: string;
    variables: string;
    currentNodeId?: string;
    errorMessage?: string;
    startedAt: string;
    completedAt?: string;
}

GetOptions#

Options for get operations

interface GetOptions {
    include?: string[];
    fields?: string[];
}

GlobalPicklist#

Global picklist definition

interface GlobalPicklist {
    id: string;
    tenantId: string;
    name: string;
    description?: string;
    sorted: boolean;
    restricted: boolean;
    createdAt: string;
    updatedAt: string;
}

GovernorLimits#

Governor limits for a tenant Governor limits configuration

interface GovernorLimits {
    apiCallsPerDay: number;
    storageGb: number;
    maxUsers: number;
    maxCollections: number;
    maxFieldsPerCollection: number;
    maxWorkflows: number;
    maxReports: number;
}
interface GovernorLimits {
    apiCallsPerDay: number;
    storageGb: number;
    maxUsers: number;
    maxCollections: number;
    maxFieldsPerCollection: number;
    maxWorkflows: number;
    maxReports: number;
}

GovernorLimitsStatus#

Governor limits status

interface GovernorLimitsStatus {
    tier: "FREE" | "PROFESSIONAL" | "ENTERPRISE" | "UNLIMITED";
    limits: GovernorLimits;
    apiCallsUsed: number;
    apiCallsLimit: number;
    usersUsed: number;
    usersLimit: number;
    collectionsUsed: number;
    collectionsLimit: number;
    storageUsedBytes: number;
    storageGbLimit: number;
    aiTokensUsed: number;
    aiTokensLimit: number;
    aiEnabled: boolean;
}

ImportApiSpecRequest#

interface ImportApiSpecRequest {
    name: string;
    description?: string;
    sourceType: "INLINE_JSON" | "INLINE_YAML" | "URL";
    sourceUrl?: string;
    raw?: string;
    rawFormat?: "json" | "yaml";
}

ImportApiSpecResponse#

interface ImportApiSpecResponse {
    spec: ApiSpecSummary;
    diff: {
        added: number;
        changed: number;
        removed: number;
    };
}

ImportResult#

Import result

interface ImportResult {
    success: boolean;
    imported: {
        collections: number;
        roles: number;
        policies: number;
    };
    errors?: string[];
}

JobExecutionLog#

interface JobExecutionLog {
    id: string;
    jobId: string;
    status: string;
    recordsProcessed: number;
    errorMessage?: string;
    startedAt: string;
    completedAt?: string;
    durationMs?: number;
}

KeltaClientConfig#

Kelta Client configuration

interface KeltaClientConfig {
    baseUrl: string;
    tenantSlug?: string;
    tokenProvider?: TokenProvider;
    cache?: CacheConfig;
    retry?: RetryConfig;
    validation?: boolean;
    axiosConfig?: Record<string, unknown>;
}

LayoutAssignment#

interface LayoutAssignment {
    id: string;
    collectionId: string;
    profileId?: string;
    recordTypeId?: string;
    layoutId: string;
    condition?: LayoutFilter | null;
    evaluationOrder: number;
    createdAt: string;
    updatedAt: string;
}

LayoutAssignmentRequest#

interface LayoutAssignmentRequest {
    collectionId: string;
    profileId?: string;
    recordTypeId?: string;
    layoutId: string;
    condition?: LayoutFilter | null;
    evaluationOrder?: number;
}

LayoutFieldPlacement#

interface LayoutFieldPlacement {
    id: string;
    fieldId: string;
    fieldName?: string;
    fieldType?: string;
    fieldDisplayName?: string;
    columnNumber: number;
    columnSpan?: number;
    sortOrder: number;
    requiredOnLayout: boolean;
    readOnlyOnLayout: boolean;
    labelOverride?: string;
    helpTextOverride?: string;
    visibilityRule?: string;
}

LayoutRelatedList#

interface LayoutRelatedList {
    id: string;
    relatedCollectionId: string;
    relationshipField: string;
    displayColumns: string;
    sortField?: string;
    sortDirection: "ASC" | "DESC";
    rowLimit: number;
    sortOrder: number;
}

LayoutSection#

interface LayoutSection {
    id: string;
    heading: string;
    columns: number;
    sortOrder: number;
    collapsed: boolean;
    style: "DEFAULT" | "COLLAPSIBLE" | "CARD";
    sectionType: "STANDARD" | "HIGHLIGHTS_PANEL" | "BLANK_SPACE";
    tabGroup?: string;
    tabLabel?: string;
    visibilityRule?: string;
    fields: LayoutFieldPlacement[];
}

ListOptions#

Options for list operations

interface ListOptions {
    page?: number;
    size?: number;
    sort?: SortCriteria[];
    filters?: FilterExpression[];
    fields?: string[];
    include?: string[];
}

ListResponse#

Response from list operations

interface ListResponse<T> {
    data: T[];
    pagination: PaginationMeta;
}

ListView#

interface ListView {
    id: string;
    tenantId: string;
    collectionId: string;
    name: string;
    columns: string;
    filters: string;
    filterLogic?: string;
    sortField?: string;
    sortDirection: "ASC" | "DESC";
    chartConfig?: string;
    visibility: "PRIVATE" | "PUBLIC" | "GROUP";
    viewType?: ListViewType;
    typeConfig?: ListViewTypeConfig | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}

ListViewTypeConfig#

interface ListViewTypeConfig {
    kanban?: {
        laneField: string;
        cardFields?: string[];
    };
    calendar?: {
        dateField: string;
        endDateField?: string;
    };
    gallery?: {
        imageField?: string;
        titleField?: string;
        cardFields?: string[];
    };
}

LoginHistoryEntry#

Login history entry

interface LoginHistoryEntry {
    id: string;
    userId: string;
    loginTime: string;
    sourceIp: string;
    loginType: "UI" | "API" | "OAUTH" | "SERVICE_ACCOUNT";
    status: "SUCCESS" | "FAILED" | "LOCKED_OUT";
    userAgent: string;
}

MetricsDataPoint#

interface MetricsDataPoint {
    timestamp: number;
    value: number;
}

MetricsQueryParams#

interface MetricsQueryParams {
    metric: string;
    start: string;
    end: string;
    step?: string;
    route?: string;
}

MetricsQueryResult#

interface MetricsQueryResult {
    metric: string;
    start: string;
    end: string;
    step: string;
    series: MetricsTimeSeries[];
}

MetricsSummary#

interface MetricsSummary {
    totalRequests: number;
    errorRate: number;
    avgLatencyMs: number;
    activeRequests: number;
    authFailures?: number;
    rateLimited?: number;
}

MetricsTimeSeries#

interface MetricsTimeSeries {
    labels: Record<string, string>;
    dataPoints: MetricsDataPoint[];
}

Migration#

Migration definition

interface Migration {
    id: string;
    name: string;
    description?: string;
    status: "pending" | "running" | "completed" | "failed";
    createdAt: string;
    completedAt?: string;
}

MigrationPlan#

Migration plan result

interface MigrationPlan {
    steps: MigrationStep[];
    warnings?: string[];
    estimatedDuration?: number;
}

MigrationResult#

Migration result

interface MigrationResult {
    success: boolean;
    message: string;
    details?: unknown;
}

MigrationRun#

Migration run details

interface MigrationRun {
    id: string;
    migrationId: string;
    status: "pending" | "running" | "completed" | "failed";
    startedAt?: string;
    completedAt?: string;
    error?: string;
    steps: MigrationStepResult[];
}

OIDCProvider#

OIDC Provider configuration

interface OIDCProvider {
    id: string;
    name: string;
    issuer: string;
    clientId: string;
    clientSecret?: string;
    scopes: string[];
    active: boolean;
    jwksUri?: string;
    authorizationUri?: string;
    tokenUri?: string;
    userinfoUri?: string;
    endSessionUri?: string;
    discoveryStatus?: string;
    rolesClaim?: string;
    rolesMapping?: string;
    emailClaim?: string;
    usernameClaim?: string;
    nameClaim?: string;
    groupsClaim?: string;
    groupsProfileMapping?: string;
}

ObjectPermissionRequest#

Request to set object permissions

interface ObjectPermissionRequest {
    canCreate: boolean;
    canRead: boolean;
    canEdit: boolean;
    canDelete: boolean;
}

ObservabilitySetting#

interface ObservabilitySetting {
    id: string;
    settingKey: string;
    settingValue: string;
}

ObservabilitySettingsResponse#

interface ObservabilitySettingsResponse {
    settings: ObservabilitySetting[];
}

OpenAPISpec#

OpenAPI specification structure (simplified for Kelta use case)

interface OpenAPISpec {
    openapi: string;
    info: {
        title: string;
        version: string;
        description?: string;
    };
    paths: Record<string, PathItem>;
    components?: {
        schemas?: Record<string, SchemaObject>;
        responses?: Record<string, ResponseObject>;
        requestBodies?: Record<string, RequestBodyObject>;
    };
}

PackageData#

Package data for import/export

interface PackageData {
    version: string;
    collections: CollectionDefinition[];
    uiConfig?: UIConfig;
}

Page#

Paginated response

interface Page<T> {
    content: T[];
    totalElements: number;
    totalPages: number;
    number: number;
    size: number;
}

PageLayout#

interface PageLayout {
    id: string;
    tenantId: string;
    collectionId: string;
    name: string;
    description?: string;
    layoutType: "DETAIL" | "EDIT" | "MINI" | "LIST";
    isDefault: boolean;
    sections: LayoutSection[];
    relatedLists: LayoutRelatedList[];
    rules?: LayoutRule[];
    defaultFilter?: LayoutFilter | null;
    defaultSortField?: string;
    defaultSortDirection?: "ASC" | "DESC";
    defaultRowLimit?: number;
    createdAt: string;
    updatedAt: string;
}

PaginationMeta#

Pagination metadata

interface PaginationMeta {
    page: number;
    size: number;
    total: number;
    totalPages: number;
}

ParsedCollection#

Parsed collection schema from OpenAPI

interface ParsedCollection {
    name: string;
    displayName: string;
    fields: ParsedField[];
    operations: string[];
}

ParsedField#

Parsed field from OpenAPI schema

interface ParsedField {
    name: string;
    type: string;
    required: boolean;
    description?: string;
    format?: string;
    enum?: (string | number | boolean)[];
    items?: ParsedField;
    properties?: ParsedField[];
}

PersonalAccessToken#

interface PersonalAccessToken {
    id: string;
    name: string;
    tokenPrefix: string;
    scopes: string[];
    expiresAt: string;
    lastUsedAt: string | null;
    createdAt: string;
}

PersonalAccessTokenCreated#

interface PersonalAccessTokenCreated {
    token: string;
    name: string;
    tokenPrefix: string;
    scopes: string[];
    expiresAt: string;
}

PicklistDependency#

Picklist dependency mapping

interface PicklistDependency {
    id: string;
    controllingFieldId: string;
    dependentFieldId: string;
    mapping: Record<string, string[]>;
}

PicklistValue#

Picklist value

interface PicklistValue {
    id: string;
    value: string;
    label: string;
    isDefault: boolean;
    isActive: boolean;
    sortOrder: number;
    color?: string;
    description?: string;
}

PicklistValueRequest#

Request to set picklist values

interface PicklistValueRequest {
    value: string;
    label: string;
    isDefault?: boolean;
    isActive?: boolean;
    sortOrder?: number;
    color?: string;
    description?: string;
}

PlatformUser#

Platform user

interface PlatformUser {
    id: string;
    email: string;
    firstName: string;
    lastName: string;
    username?: string;
    status: "ACTIVE" | "INACTIVE" | "LOCKED" | "PENDING_ACTIVATION";
    userType?: "INTERNAL" | "PORTAL";
    locale: string;
    timezone: string;
    profileId?: string;
    managerId?: string;
    lastLoginAt?: string;
    loginCount: number;
    mfaEnabled: boolean;
    createdAt: string;
    updatedAt: string;
}

Profile#

Profile definition

interface Profile {
    id: string;
    name: string;
    description?: string;
    system: boolean;
    objectPermissions?: ObjectPermission[];
    fieldPermissions?: FieldPermissionEntry[];
    systemPermissions?: SystemPermissionEntry[];
    createdAt: string;
    updatedAt: string;
}

RecordType#

Record type definition

interface RecordType {
    id: string;
    collectionId: string;
    name: string;
    description?: string;
    isActive: boolean;
    active: boolean;
    isDefault: boolean;
    createdAt: string;
    updatedAt: string;
}

RecordTypePicklistOverride#

Picklist value override for a record type — one record-type-picklists row.

interface RecordTypePicklistOverride {
    id: string;
    recordTypeId?: string;
    fieldId: string;
    fieldName: string;
    availableValues: string[];
    defaultValue?: string;
}

RelationshipInfo#

Relationship information for a field

interface RelationshipInfo {
    fieldId: string;
    fieldName: string;
    relationshipType: "LOOKUP" | "MASTER_DETAIL";
    relationshipName: string;
    targetCollectionId: string;
    targetCollectionName: string;
    cascadeDelete: boolean;
}

Report#

interface Report {
    id: string;
    name: string;
    description?: string;
    reportType: "TABULAR" | "SUMMARY" | "MATRIX";
    primaryCollectionId: string;
    relatedJoins: string;
    columns: string;
    filters: string;
    filterLogic?: string;
    rowGroupings: string;
    columnGroupings: string;
    sortOrder: string;
    chartType?: string;
    chartConfig?: string;
    scope: "MY_RECORDS" | "ALL_RECORDS" | "MY_TEAM_RECORDS";
    folderId?: string;
    accessLevel: "PRIVATE" | "PUBLIC" | "HIDDEN";
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}

ResourceMetadata#

Resource metadata from discovery endpoint

interface ResourceMetadata {
    name: string;
    displayName: string;
    fields: FieldDefinition[];
    operations: string[];
    authz?: AuthzConfig;
}

RetryConfig#

Retry configuration options

interface RetryConfig {
    maxAttempts?: number;
    backoffMultiplier?: number;
    maxDelay?: number;
}

SaveDelegatedAdminScopeRequest#

Create/update payload for a delegated-admin scope.

interface SaveDelegatedAdminScopeRequest {
    name?: string;
    description?: string;
    active?: boolean;
    delegatedUserIds?: string[];
    manageableProfileIds?: string[];
    canCreateUsers?: boolean;
    canDeactivateUsers?: boolean;
    canResetPasswords?: boolean;
}

ScheduledJob#

interface ScheduledJob {
    id: string;
    name: string;
    description?: string;
    jobType: "FLOW" | "SCRIPT" | "REPORT_EXPORT";
    jobReferenceId?: string;
    cronExpression: string;
    timezone: string;
    active: boolean;
    lastRunAt?: string;
    lastStatus?: string;
    nextRunAt?: string;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}

Script#

interface Script {
    id: string;
    tenantId: string;
    name: string;
    description?: string;
    scriptType: "BEFORE_TRIGGER" | "AFTER_TRIGGER" | "SCHEDULED" | "API_ENDPOINT" | "VALIDATION" | "EVENT_HANDLER" | "EMAIL_HANDLER";
    language: string;
    sourceCode: string;
    active: boolean;
    version: number;
    createdBy: string;
    triggers: ScriptTrigger[];
    createdAt: string;
    updatedAt: string;
}

ScriptExecutionLog#

interface ScriptExecutionLog {
    id: string;
    tenantId: string;
    scriptId: string;
    status: "SUCCESS" | "FAILURE" | "TIMEOUT" | "GOVERNOR_LIMIT";
    triggerType?: string;
    recordId?: string;
    durationMs?: number;
    cpuMs?: number;
    queriesExecuted: number;
    dmlRows: number;
    callouts: number;
    errorMessage?: string;
    logOutput?: string;
    executedAt: string;
}

ScriptLayoutRule#

SCRIPT rule — a general client event handler evaluating a sandboxed @kelta/formula expression on its when events. The result is treated as a validation message: a non-empty string surfaces on target (or the form when target is omitted); a boolean true uses the static message; any falsy result clears it. On onBeforeSave a non-empty message blocks the submit (client-side UX only — the server record-event hook, slice 7, is authoritative and cannot be bypassed via the API).

interface ScriptLayoutRule extends BaseLayoutRule {
    kind: "script";
    target?: string;
    expression: string;
    message?: string;
}

SearchIndexCollectionStats#

interface SearchIndexCollectionStats {
    collectionId: string;
    collectionName: string;
    indexedRecords: number;
}

SearchIndexStats#

interface SearchIndexStats {
    totalIndexed: number;
    collections: SearchIndexCollectionStats[];
}

SearchReindexResult#

interface SearchReindexResult {
    status: string;
    collection: string;
    message: string;
}

SetDependencyRequest#

Request to set a picklist dependency

interface SetDependencyRequest {
    controllingFieldId: string;
    dependentFieldId: string;
    mapping: Record<string, string[]>;
}

SetPicklistOverrideRequest#

Request to set picklist override for a record type

interface SetPicklistOverrideRequest {
    availableValues: string[];
    defaultValue?: string;
}

SetupAuditTrailEntry#

Setup audit trail entry

interface SetupAuditTrailEntry {
    id: string;
    userId: string | null;
    action: "CREATED" | "UPDATED" | "DELETED" | "ACTIVATED" | "DEACTIVATED";
    section: string;
    entityType: string;
    entityId?: string;
    entityName?: string;
    oldValue?: string;
    newValue?: string;
    timestamp: string;
}

SortCriteria#

Sort criteria for list operations

interface SortCriteria {
    field: string;
    direction: "asc" | "desc";
}

SupersetDashboard#

interface SupersetDashboard {
    id: number;
    dashboard_title: string;
    url: string;
    status: string;
    published: boolean;
    changed_on_utc: string;
    embedded_id?: string;
}

SupersetDataset#

interface SupersetDataset {
    id: number;
    table_name: string;
    database_name: string;
    changed_on_utc: string;
}

SupersetGuestTokenResponse#

interface SupersetGuestTokenResponse {
    token: string;
    supersetDomain: string;
}

SvixPortalResponse#

interface SvixPortalResponse {
    token: string;
    appId: string;
    serverUrl: string;
}

SystemPermissionRequest#

Request to set system permissions

interface SystemPermissionRequest {
    permissionKey: string;
    granted: boolean;
}

Tenant#

Tenant definition

interface Tenant {
    id: string;
    slug: string;
    name: string;
    edition: "FREE" | "PROFESSIONAL" | "ENTERPRISE" | "UNLIMITED";
    status: "PROVISIONING" | "ACTIVE" | "SUSPENDED" | "DECOMMISSIONED";
    settings?: string;
    limits?: string;
    createdAt: string;
    updatedAt: string;
}

TenantAdminInviteResponse#

Result of inviting a tenant’s seeded admin

interface TenantAdminInviteResponse {
    status: "INVITED";
    tenantId: string;
    userId: string;
    email: string;
}

TenantBootstrapTokenRequest#

Options for minting a tenant bootstrap token

interface TenantBootstrapTokenRequest {
    expiresIn?: string;
    userId?: string;
}

TenantBootstrapTokenResponse#

A short-lived PAT minted in the target tenant. token is shown once — store it now.

interface TenantBootstrapTokenResponse {
    token: string;
    tokenPrefix: string;
    name: string;
    tenantId: string;
    userId: string;
    expiresAt: string;
}

TokenProvider#

Token provider interface for authentication

interface TokenProvider {
    getToken(): Promise<string | null>;
    refreshToken?(): Promise<string>;
}

TransformLayoutRule#

interface TransformLayoutRule extends BaseLayoutRule {
    kind: "transform";
    target: string;
    transform: {
        type: "upper" | "lower" | "trim" | "titleCase";
    } | {
        type: "formula";
        formula: string;
    };
}

TypeGenerationOptions#

CLI options for type generation

interface TypeGenerationOptions {
    url: string;
    output: string;
    includeRequests?: boolean;
    includeResponses?: boolean;
}

TypeGenerationResult#

Type generation result

interface TypeGenerationResult {
    success: boolean;
    typesGenerated: number;
    outputPath: string;
    errors?: string[];
}

UIConfig#

UI configuration

interface UIConfig {
    theme?: ThemeConfig;
    branding?: BrandingConfig;
    features?: Record<string, boolean>;
}

UIMenu#

UI Menu definition

interface UIMenu {
    id?: string;
    name: string;
    items: UIMenuItem[];
    position?: string;
    icon?: string;
    isDefault?: boolean;
    active?: boolean;
    displayOrder?: number;
}

UIPage#

UI Page definition

interface UIPage {
    id?: string;
    name: string;
    path: string;
    component?: string;
    layout?: string;
    metadata?: Record<string, unknown>;
}

UpdateObservabilitySettingsRequest#

interface UpdateObservabilitySettingsRequest {
    settings: {
        settingKey: string;
        settingValue: string;
    }[];
}

UpdatePlatformUserRequest#

Request to update a user

interface UpdatePlatformUserRequest {
    firstName?: string;
    lastName?: string;
    username?: string;
    locale?: string;
    timezone?: string;
    managerId?: string;
    profileId?: string;
}

UpdateProfileRequest#

Request to update a profile

interface UpdateProfileRequest {
    name?: string;
    description?: string;
}

UpdateTenantRequest#

Request to update a tenant

interface UpdateTenantRequest {
    name?: string;
    edition?: string;
    settings?: Record<string, unknown>;
    limits?: Partial<GovernorLimits>;
}

User#

User information

interface User {
    id: string;
    username: string;
    email?: string;
    roles: string[];
    attributes?: Record<string, unknown>;
}

UserDashboard#

interface UserDashboard {
    id: string;
    name: string;
    description?: string;
    folderId?: string;
    accessLevel: "PRIVATE" | "PUBLIC" | "HIDDEN";
    dynamic: boolean;
    runningUserId?: string;
    columnCount: number;
    createdBy: string;
    components: DashboardComponent[];
    createdAt: string;
    updatedAt: string;
}

ValidateLayoutRule#

interface ValidateLayoutRule extends BaseLayoutRule {
    kind: "validate";
    target?: string;
    formula: string;
    errorMessage: string;
    enforce: LayoutRuleEnforce;
}

ValidationRule#

Validation rule for a field

interface ValidationRule {
    type: "min" | "max" | "pattern" | "email" | "url" | "custom";
    value?: unknown;
    message?: string;
}

VisibilityRule#

Visibility rule for conditional field/section display. The rule is stored as a JSON string in the API but this type represents the parsed structure for client-side evaluation.

interface VisibilityRule {
    fieldName: string;
    operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "IS_EMPTY" | "IS_NOT_EMPTY";
    value?: string;
    logic?: "AND" | "OR";
    conditions?: VisibilityRule[];
}

WebhookUrlResponse#

interface WebhookUrlResponse {
    webhookUrl: string;
    flowId: string;
}

Type aliases#

CampaignStatus#

type CampaignStatus = "DRAFT" | "SCHEDULED" | "QUEUED" | "SENDING" | "SENT" | "FAILED" | "CANCELLED";

FieldType#

Supported field types

type FieldType = "string" | "number" | "boolean" | "date" | "datetime" | "json" | "reference" | "picklist" | "multi_picklist" | "currency" | "percent" | "auto_number" | "phone" | "email" | "url" | "rich_text" | "encrypted" | "external_id" | "geolocation" | "lookup" | "master_detail" | "formula" | "rollup_summary";

JsonObjectField#

A field backed by a Postgres jsonb column, so its wire shape is a real JSON object — not a JSON string.

type JsonObjectField = object;

LayoutRule#

type LayoutRule = ComputeLayoutRule | ValidateLayoutRule | DefaultLayoutRule | TransformLayoutRule | ScriptLayoutRule;

LayoutRuleEnforce#

type LayoutRuleEnforce = "block" | "warn";

LayoutRuleEvent#

type LayoutRuleEvent = "onChange" | "onBlur" | "onLoad" | "onBeforeSave";

LayoutRuleKind#

type LayoutRuleKind = "compute" | "validate" | "default" | "transform" | "script";

LayoutRuleTransformType#

type LayoutRuleTransformType = "upper" | "lower" | "trim" | "titleCase";

ListViewType#

type ListViewType = "TABLE" | "KANBAN" | "CALENDAR" | "GALLERY";

UpdateLayoutRuleRequest#

type UpdateLayoutRuleRequest = Partial<CreateLayoutRuleRequest>;

Edit this page on GitHub