@teamkeel/functions-runtime 0.412.0 → 0.413.0-next.1

package/dist/index.d.ts

@@ -0,0 +1,733 @@
+import * as kysely from 'kysely';
+import { Kysely } from 'kysely';
+export { default as KSUID } from 'ksuid';
+import * as opentelemetry from '@opentelemetry/api';
+
+declare namespace ErrorPresets {
+    export { NotFoundError$1 as NotFound };
+    export { BadRequestError as BadRequest };
+    export { UnknownError as Unknown };
+}
+declare class NotFoundError$1 extends Error {
+    constructor(message: any);
+    errorCode: number;
+}
+
+/**
+ * QueryContext is used to store state about the current query, for example
+ * which joins have already been applied. It is used by applyJoins and
+ * applyWhereConditions to generate consistent table aliases for joins.
+ *
+ * This class has the concept of a "table path". This is just a list of tables, starting
+ * with some "root" table and ending with the table we're currently joining to. So
+ * for example if we started with a "product" table and joined from there to "order_item"
+ * and then to "order" and then to "customer" the table path would be:
+ *   ["product", "order_item", "order", "customer"]
+ * At this point the "current" table is "customer" and it's alias would be:
+ *   "product$order_item$order$customer"
+ */
+declare class QueryContext {
+    /**
+     * @param {string[]} tablePath This is the path from the "root" table to the "current table".
+     * @param {import("./ModelAPI").TableConfigMap} tableConfigMap
+     * @param {string[]} joins
+     */
+    constructor(tablePath: string[], tableConfigMap: TableConfigMap, joins?: string[]);
+    _tablePath: string[];
+    _tableConfigMap: {
+        [x: string]: {
+            [x: string]: RelationshipConfig;
+        };
+    };
+    _joins: string[];
+    clone(): QueryContext;
+    /**
+     * Returns true if, given the current table path, a join to the given
+     * table has already been added.
+     * @param {string} table
+     * @returns {boolean}
+     */
+    hasJoin(table: string): boolean;
+    /**
+     * Adds table to the QueryContext's path and registers the join,
+     * calls fn, then pops the table off the path.
+     * @param {string} table
+     * @param {Function} fn
+     */
+    withJoin(table: string, fn: Function): void;
+    /**
+     * Returns the alias that will be used for the current table
+     * @returns {string}
+     */
+    tableAlias(): string;
+    /**
+     * Returns the current table name
+     * @returns {string}
+     */
+    tableName(): string;
+    /**
+     * Return the TableConfig for the current table
+     * @returns {import("./ModelAPI").TableConfig | undefined}
+     */
+    tableConfig(): TableConfig | undefined;
+}
+
+declare class QueryBuilder {
+    /**
+     * @param {string} tableName
+     * @param {import("./QueryContext").QueryContext} context
+     * @param {import("kysely").Kysely} db
+     */
+    constructor(tableName: string, context: QueryContext, db: kysely.Kysely<any>);
+    _tableName: string;
+    _context: QueryContext;
+    _db: kysely.Kysely<any>;
+    _modelName: any;
+    where(where: any): QueryBuilder;
+    sql(): any;
+    update(values: any): Promise<any>;
+    delete(): Promise<any>;
+    findOne(): Promise<any>;
+    findMany(params: any): Promise<any>;
+}
+
+/**
+ * TableConfig is an object where the keys are relationship field names
+ * (which don't exist in the database) and the values are RelationshipConfig
+ * objects describing that relationship.
+ */
+type RelationshipConfig = {
+    relationshipType: "belongsTo" | "hasMany";
+    foreignKey: string;
+    referencesTable: string;
+};
+/**
+ * TableConfigMap is mapping of database table names to TableConfig objects
+ */
+type TableConfig = {
+    [x: string]: RelationshipConfig;
+};
+/**
+ * RelationshipConfig is a simple representation of a model field that
+ * is a relationship. It is used by applyJoins and applyWhereConditions
+ * to build the correct query.
+ */
+type TableConfigMap = {
+    [x: string]: {
+        [x: string]: RelationshipConfig;
+    };
+};
+/**
+ * RelationshipConfig is a simple representation of a model field that
+ * is a relationship. It is used by applyJoins and applyWhereConditions
+ * to build the correct query.
+ * @typedef {{
+ *  relationshipType: "belongsTo" | "hasMany",
+ *  foreignKey: string,
+ *  referencesTable: string,
+ * }} RelationshipConfig
+ *
+ * TableConfig is an object where the keys are relationship field names
+ * (which don't exist in the database) and the values are RelationshipConfig
+ * objects describing that relationship.
+ * @typedef {Object.<string, RelationshipConfig} TableConfig
+ *
+ * TableConfigMap is mapping of database table names to TableConfig objects
+ * @typedef {Object.<string, TableConfig>} TableConfigMap
+ */
+declare class ModelAPI {
+    /**
+     * @param {string} tableName The name of the table this API is for
+     * @param {Function} _ Used to be a function that returns the default values for a row in this table. No longer used.
+     * @param {TableConfigMap} tableConfigMap
+     */
+    constructor(tableName: string, _: Function, tableConfigMap?: TableConfigMap);
+    _tableName: string;
+    _tableConfigMap: {
+        [x: string]: {
+            [x: string]: RelationshipConfig;
+        };
+    };
+    _modelName: any;
+    create(values: any): Promise<any>;
+    findOne(where?: {}): Promise<any>;
+    findMany(params: any): Promise<any>;
+    update(where: any, values: any): Promise<any>;
+    delete(where: any): Promise<any>;
+    where(where: any): QueryBuilder;
+}
+
+interface RequestHeadersMap {
+    [key: string]: string;
+}
+declare class RequestHeaders {
+    private _headers;
+    /**
+     * @param {{Object.<string, string>}} requestHeaders Map of request headers submitted from the client
+     */
+    constructor(requestHeaders: RequestHeadersMap);
+    get: Headers["get"];
+    has: Headers["has"];
+}
+
+declare function handleRequest(request: any, config: any): Promise<any>;
+
+declare function handleJob(request: any, config: any): Promise<any>;
+
+declare function handleSubscriber(request: any, config: any): Promise<any>;
+
+declare function handleRoute(request: any, config: any): Promise<any>;
+
+declare function handleFlow(request: any, config: any): Promise<any>;
+
+declare function useDatabase(): Kysely<any>;
+
+declare const PERMISSION_STATE: {
+    readonly UNKNOWN: "unknown";
+    readonly PERMITTED: "permitted";
+    readonly UNPERMITTED: "unpermitted";
+};
+type PermissionState = (typeof PERMISSION_STATE)[keyof typeof PERMISSION_STATE];
+/**
+ * Permissions class for managing access control in the runtime
+ */
+declare class Permissions {
+    /**
+     * Explicitly permit access to an action
+     */
+    allow(): void;
+    /**
+     * Explicitly deny access to an action
+     */
+    deny(): never;
+    getState(): PermissionState;
+}
+interface CheckBuiltInPermissionsParams {
+    rows: any[];
+    permissionFns: Array<(rows: any[], ctx: any, db: any) => Promise<boolean>>;
+    ctx: any;
+    db: any;
+    functionName: string;
+}
+declare const checkBuiltInPermissions: ({ rows, permissionFns, ctx, db, functionName, }: CheckBuiltInPermissionsParams) => Promise<void>;
+
+declare function getTracer(): opentelemetry.Tracer;
+declare function withSpan(name: any, fn: any): Promise<any>;
+declare function init(): void;
+declare function forceFlush(): Promise<void>;
+declare function spanNameForModelAPI(modelName: any, action: any): string;
+
+declare const tracing_forceFlush: typeof forceFlush;
+declare const tracing_getTracer: typeof getTracer;
+declare const tracing_init: typeof init;
+declare const tracing_spanNameForModelAPI: typeof spanNameForModelAPI;
+declare const tracing_withSpan: typeof withSpan;
+declare namespace tracing {
+  export { tracing_forceFlush as forceFlush, tracing_getTracer as getTracer, tracing_init as init, tracing_spanNameForModelAPI as spanNameForModelAPI, tracing_withSpan as withSpan };
+}
+
+type MimeType = "application/json" | "application/gzip" | "application/pdf" | "application/rtf" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.ms-excel" | "application/vnd.ms-powerpoint" | "application/msword" | "application/zip" | "application/xml" | "application/x-7z-compressed" | "application/x-tar" | "image/gif" | "image/jpeg" | "image/svg+xml" | "image/png" | "text/html" | "text/csv" | "text/javascript" | "text/plain" | "text/calendar" | (string & {});
+type InlineFileConstructor = {
+    filename: string;
+    contentType: MimeType;
+};
+type FileDbRecord = {
+    key: string;
+    filename: string;
+    contentType: string;
+    size: number;
+};
+declare class InlineFile {
+    protected _filename: string;
+    protected _contentType: MimeType;
+    protected _contents: Blob | null;
+    constructor(input: InlineFileConstructor);
+    static fromDataURL(dataURL: string): InlineFile;
+    get size(): number;
+    get contentType(): string;
+    get filename(): string;
+    write(buffer: Buffer): void;
+    read(): Promise<Buffer>;
+    store(expires?: Date | null): Promise<File>;
+}
+declare class File extends InlineFile {
+    private _key;
+    private _size;
+    constructor(input: Partial<FileDbRecord>);
+    static fromDbRecord(input: FileDbRecord): File;
+    get size(): number;
+    get key(): string;
+    get isPublic(): boolean;
+    read(): Promise<Buffer>;
+    store(expires?: Date | null): Promise<File>;
+    getPresignedUrl(): Promise<URL>;
+    toDbRecord(): FileDbRecord;
+    toJSON(): FileDbRecord;
+}
+
+declare class Duration {
+    private _typename;
+    private pgInterval;
+    private _interval;
+    constructor(postgresString: string);
+    static fromISOString(isoString: string): Duration;
+    toISOString(): string;
+    toPostgres(): string;
+}
+
+type ElementDataType$3 = string | number | boolean | Date;
+type UiElementSelectOne = <TValue extends ElementDataType$3, N extends string>(name: N, options?: BaseInputConfig<TValue> & {
+    options: ({
+        label: string;
+        value: TValue;
+    } | TValue)[];
+}) => InputElementResponse<N, TValue>;
+interface UiElementSelectOneApiResponse extends BaseUiInputResponse<"ui.select.single", ElementDataType$3> {
+    options: ({
+        label: string;
+        value: ElementDataType$3;
+    } | ElementDataType$3)[];
+}
+
+type ElementDataType$2 = string;
+type UiElementInputText = InputElement<ElementDataType$2, {
+    placeholder?: string;
+    multiline?: boolean;
+    maxLength?: number;
+    minLength?: number;
+}>;
+interface UiElementInputTextApiResponse extends BaseUiInputResponse<"ui.input.text", ElementDataType$2> {
+    placeholder?: string;
+    multiline?: boolean;
+    maxLength?: number;
+    minLength?: number;
+}
+
+type ElementDataType$1 = number;
+type UiElementInputNumber = InputElement<ElementDataType$1, {
+    placeholder?: number;
+    min?: number;
+    max?: number;
+}>;
+interface UiElementInputNumberApiResponse extends BaseUiInputResponse<"ui.input.number", ElementDataType$1> {
+    placeholder?: number;
+    min?: number;
+    max?: number;
+}
+
+type ElementDataType = boolean;
+type UiElementInputBoolean = InputElement<ElementDataType, {
+    mode?: "checkbox" | "switch";
+}>;
+interface UiElementInputBooleanApiResponse extends BaseUiInputResponse<"ui.input.boolean", ElementDataType> {
+    mode: "checkbox" | "switch";
+}
+
+type UiElementMarkdown = DisplayElement<{
+    content: string;
+}>;
+interface UiElementMarkdownApiResponse extends BaseUiDisplayResponse<"ui.display.markdown"> {
+    content: string;
+}
+
+type TableData<T extends Record<string, any>> = {
+    data: T[];
+    columns?: Array<Extract<keyof T, string>>;
+};
+type UiElementTable = <const T extends Record<string, any>>(options: TableData<T>) => DisplayElementResponse;
+interface UiElementTableApiResponse extends BaseUiDisplayResponse<"ui.display.table"> {
+    data: any[];
+    columns?: string[];
+}
+
+type UiElementDivider = DisplayElement<{}>;
+interface UiElementDividerApiResponse extends BaseUiDisplayResponse<"ui.display.divider"> {
+}
+
+type UiPage<C extends FlowConfig> = <T extends UIElements, A extends PageActions[] = []>(name: string, options: {
+    stage?: ExtractStageKeys<C>;
+    title?: string;
+    description?: string;
+    content: T;
+    validate?: (data: ExtractFormData<T>) => Promise<true | string>;
+    actions?: A;
+}) => A["length"] extends 0 ? ExtractFormData<T> : {
+    data: ExtractFormData<T>;
+    action: ActionValue<A[number]>;
+};
+type PageActions = string | {
+    label: string;
+    value: string;
+    mode?: "primary" | "secondary" | "destructive";
+};
+type ActionValue<T> = T extends string ? T : T extends {
+    value: infer V;
+} ? V : never;
+type ExtractFormData<T extends UIElements> = {
+    [K in Extract<T[number], InputElementResponse<string, any>>["name"]]: Extract<T[number], InputElementResponse<K, any>>["valueType"];
+};
+
+type UiElementImage = DisplayElement<{
+    url: string;
+    alt?: string;
+    size?: "thumbnail" | "small" | "medium" | "large" | "full";
+    title?: string;
+}>;
+interface UiElementImageApiResponse extends BaseUiDisplayResponse<"ui.display.image"> {
+    url: string;
+    alt?: string;
+    size?: "thumbnail" | "small" | "medium" | "large" | "full";
+    title?: string;
+}
+
+type BannerMode = "info" | "warning" | "error" | "success";
+type UiElementBanner = DisplayElement<{
+    title: string;
+    description: string;
+    mode?: BannerMode;
+}>;
+interface UiElementBannerApiResponse extends BaseUiDisplayResponse<"ui.display.banner"> {
+    title: string;
+    description: string;
+    mode: BannerMode;
+}
+
+type UiElementHeader = DisplayElement<{
+    level: 1 | 2 | 3;
+    title?: string;
+    description?: string;
+}>;
+interface UiElementHeaderApiResponse extends BaseUiDisplayResponse<"ui.display.header"> {
+    level: number;
+    title: string;
+    description: string;
+}
+
+type UiElementCode = DisplayElement<{
+    code: string;
+    language?: string;
+}>;
+interface UiElementCodeApiResponse extends BaseUiDisplayResponse<"ui.display.code"> {
+    code: string;
+    language?: string;
+}
+
+type ImageConfig$1 = {
+    url: string;
+    alt?: string;
+    aspectRatio?: number;
+    fit?: "cover" | "contain";
+};
+type GridItem = {
+    title?: string;
+    description?: string;
+    image?: ImageConfig$1;
+};
+type GridOptions<T> = {
+    data: T[];
+    render: (data: T) => GridItem;
+};
+type UiElementGrid = <T extends any>(options: GridOptions<T>) => DisplayElementResponse;
+interface UiElementGridApiResponse extends BaseUiDisplayResponse<"ui.display.grid"> {
+    data: any[];
+}
+
+type ImageConfig = {
+    url: string;
+    alt?: string;
+    fit?: "cover" | "contain";
+};
+type ListItem = {
+    title?: string;
+    description?: string;
+    image?: ImageConfig;
+};
+type ListOptions<T> = {
+    data: T[];
+    render: (data: T) => ListItem;
+};
+type UiElementList = <T extends any>(options: ListOptions<T>) => DisplayElementResponse;
+interface UiElementListApiResponse extends BaseUiDisplayResponse<"ui.display.list"> {
+    data: any[];
+}
+
+interface UI<C extends FlowConfig> {
+    page: UiPage<C>;
+    display: UiDisplayElements;
+    inputs: UiInputsElements;
+    select: UiSelectElements;
+}
+type UiInputsElements = {
+    text: UiElementInputText;
+    number: UiElementInputNumber;
+    boolean: UiElementInputBoolean;
+};
+type UiSelectElements = {
+    single: UiElementSelectOne;
+};
+type UiDisplayElements = {
+    divider: UiElementDivider;
+    markdown: UiElementMarkdown;
+    header: UiElementHeader;
+    banner: UiElementBanner;
+    image: UiElementImage;
+    code: UiElementCode;
+    grid: UiElementGrid;
+    list: UiElementList;
+    table: UiElementTable;
+};
+type InputElement<TValueType, TConfig extends any = never> = <N extends string>(name: N, options?: BaseInputConfig<TValueType> & TConfig) => InputElementResponse<N, TValueType>;
+type DisplayElement<TConfig extends any = never> = (options?: TConfig) => DisplayElementResponse;
+type UIElements = (InputElementResponse<string, any> | DisplayElementResponse)[];
+interface UIElementBase {
+    _type: string;
+}
+interface InputElementResponse<N extends string, V> extends UIElementBase {
+    _type: "input";
+    name: N;
+    valueType: V;
+}
+interface DisplayElementResponse extends UIElementBase {
+    _type: "display";
+}
+interface BaseInputConfig<T> {
+    label?: string;
+    defaultValue?: T;
+    helpText?: string;
+    optional?: boolean;
+    disabled?: boolean;
+    validate?: (data: T) => Promise<boolean | string>;
+}
+interface BaseUiInputResponse<K, TData> {
+    __type: K;
+    name: string;
+    label: string;
+    defaultValue?: TData;
+    helpText?: string;
+    optional?: boolean;
+    disabled?: boolean;
+}
+interface BaseUiDisplayResponse<K> {
+    __type: K;
+}
+type UIApiResponses = {
+    display: {
+        divider: UiElementDividerApiResponse;
+        markdown: UiElementMarkdownApiResponse;
+        header: UiElementHeaderApiResponse;
+        banner: UiElementBannerApiResponse;
+        image: UiElementImageApiResponse;
+        code: UiElementCodeApiResponse;
+        grid: UiElementGridApiResponse;
+        list: UiElementListApiResponse;
+        table: UiElementTableApiResponse;
+    };
+    input: {
+        text: UiElementInputTextApiResponse;
+        number: UiElementInputNumberApiResponse;
+        boolean: UiElementInputBooleanApiResponse;
+    };
+    select: {
+        single: UiElementSelectOneApiResponse;
+    };
+};
+
+interface FlowContext<C extends FlowConfig> {
+    step: Step<C>;
+    ui: UI<C>;
+}
+type Step<C extends FlowConfig> = <R>(name: string, options: {
+    stage?: ExtractStageKeys<C>;
+    maxRetries?: number;
+    timeoutInMs?: number;
+}, fn: () => Promise<R> & {
+    catch: (errorHandler: (err: Error) => Promise<void> | void) => Promise<any>;
+}) => Promise<R>;
+interface FlowConfig {
+    stages?: StageConfig[];
+    title?: string;
+    description?: string;
+}
+type FlowFunction<C extends FlowConfig, I extends any = {}> = (ctx: FlowContext<C>, inputs: I) => Promise<void>;
+type ExtractStageKeys<T extends FlowConfig> = T extends {
+    stages: infer S;
+} ? S extends ReadonlyArray<infer U> ? U extends string ? U : U extends {
+    key: infer K extends string;
+} ? K : never : never : never;
+type StageConfig = string | {
+    key: string;
+    name: string;
+    description?: string;
+    initiallyHidden?: boolean;
+};
+declare function createFlowContext<C extends FlowConfig>(runId: string, data: any, spanId: string): FlowContext<C>;
+
+declare function ksuid(): string;
+
+type IDWhereCondition = {
+    equals?: string | null;
+    notEquals?: string | null;
+    oneOf?: string[] | null;
+};
+type StringWhereCondition = {
+    startsWith?: string | null;
+    endsWith?: string | null;
+    oneOf?: string[] | null;
+    contains?: string | null;
+    equals?: string | null;
+    notEquals?: string | null;
+};
+type BooleanWhereCondition = {
+    equals?: boolean | null;
+    notEquals?: boolean | null;
+};
+type NumberWhereCondition = {
+    greaterThan?: number | null;
+    greaterThanOrEquals?: number | null;
+    lessThan?: number | null;
+    lessThanOrEquals?: number | null;
+    equals?: number | null;
+    notEquals?: number | null;
+};
+type DurationWhereCondition = {
+    greaterThan?: DurationString | null;
+    greaterThanOrEquals?: DurationString | null;
+    lessThan?: DurationString | null;
+    lessThanOrEquals?: DurationString | null;
+    equals?: DurationString | null;
+    notEquals?: DurationString | null;
+};
+type DateWhereCondition = {
+    equals?: Date | string | null;
+    equalsRelative?: RelativeDateString | null;
+    before?: Date | string | null;
+    beforeRelative?: RelativeDateString | null;
+    onOrBefore?: Date | string | null;
+    after?: Date | string | null;
+    afterRelative?: RelativeDateString | null;
+    onOrAfter?: Date | string | null;
+};
+type DateQueryInput = {
+    equals?: string | null;
+    before?: string | null;
+    onOrBefore?: string | null;
+    after?: string | null;
+    onOrAfter?: string | null;
+};
+type TimestampQueryInput = {
+    before: string | null;
+    after: string | null;
+    equalsRelative?: RelativeDateString | null;
+    beforeRelative?: RelativeDateString | null;
+    afterRelative?: RelativeDateString | null;
+};
+type StringArrayWhereCondition = {
+    equals?: string[] | null;
+    notEquals?: string[] | null;
+    any?: StringArrayQueryWhereCondition | null;
+    all?: StringArrayQueryWhereCondition | null;
+};
+type StringArrayQueryWhereCondition = {
+    equals?: string | null;
+    notEquals?: string | null;
+};
+type NumberArrayWhereCondition = {
+    equals?: number[] | null;
+    notEquals?: number[] | null;
+    any?: NumberArrayQueryWhereCondition | null;
+    all?: NumberArrayQueryWhereCondition | null;
+};
+type NumberArrayQueryWhereCondition = {
+    greaterThan?: number | null;
+    greaterThanOrEquals?: number | null;
+    lessThan?: number | null;
+    lessThanOrEquals?: number | null;
+    equals?: number | null;
+    notEquals?: number | null;
+};
+type BooleanArrayWhereCondition = {
+    equals?: boolean[] | null;
+    notEquals?: boolean[] | null;
+    any?: BooleanArrayQueryWhereCondition | null;
+    all?: BooleanArrayQueryWhereCondition | null;
+};
+type BooleanArrayQueryWhereCondition = {
+    equals?: boolean | null;
+    notEquals?: boolean | null;
+};
+type DateArrayWhereCondition = {
+    equals?: Date[] | null;
+    notEquals?: Date[] | null;
+    any?: DateArrayQueryWhereCondition | null;
+    all?: DateArrayQueryWhereCondition | null;
+};
+type DateArrayQueryWhereCondition = {
+    greaterThan?: Date | null;
+    greaterThanOrEquals?: Date | null;
+    lessThan?: Date | null;
+    lessThanOrEquals?: number | null;
+    equals?: Date | null;
+    notEquals?: Date | null;
+};
+type ContextAPI = {
+    headers: RequestHeaders;
+    response: Response;
+    isAuthenticated: boolean;
+    now(): Date;
+};
+type Response = {
+    headers: Headers;
+    status?: number;
+};
+type PageInfo = {
+    startCursor: string;
+    endCursor: string;
+    totalCount: number;
+    hasNextPage: boolean;
+    count: number;
+    pageNumber?: number;
+};
+type SortDirection = "asc" | "desc" | "ASC" | "DESC";
+declare class NotFoundError extends Error {
+}
+declare class BadRequestError$1 extends Error {
+}
+declare class UnknownError$1 extends Error {
+}
+type Errors = {
+    /**
+     * Returns a 404 HTTP status with an optional message.
+     * This error indicates that the requested resource could not be found.
+     */
+    NotFound: typeof NotFoundError;
+    /**
+     * Returns a 400 HTTP status with an optional message.
+     * This error indicates that the request made by the client is invalid or malformed.
+     */
+    BadRequest: typeof BadRequestError$1;
+    /**
+     * Returns a 500 HTTP status with an optional message.
+     * This error indicates that an unexpected condition was encountered, preventing the server from fulfilling the request.
+     */
+    Unknown: typeof UnknownError$1;
+};
+type FunctionConfig = {
+    /**
+     * All DB calls within the function will be executed within a transaction.
+     * The transaction is rolled back if the function throws an error.
+     */
+    dbTransaction?: boolean;
+};
+type FuncWithConfig<T> = T & {
+    config: FunctionConfig;
+};
+type unit = "year" | "years" | "month" | "months" | "day" | "days" | "hour" | "hours" | "minute" | "minutes" | "second" | "seconds";
+type direction = "next" | "last";
+type completed = "complete";
+type value = number;
+type RelativeDateString = "now" | "today" | "tomorrow" | "yesterday" | `this ${unit}` | `${direction} ${unit}` | `${direction} ${value} ${unit}` | `${direction} ${value} ${completed} ${unit}`;
+type dateDuration = `${number}Y${number}M${number}D` | `${number}Y${number}M` | `${number}Y${number}D` | `${number}M${number}D` | `${number}Y` | `${number}M` | `${number}D`;
+type timeDuration = `${number}H${number}M${number}S` | `${number}H${number}M` | `${number}M${number}S` | `${number}H${number}S` | `${number}H` | `${number}M` | `${number}S`;
+type DurationString = `P${dateDuration}T${timeDuration}` | `P${dateDuration}` | `PT${timeDuration}`;
+
+export { type BooleanArrayQueryWhereCondition, type BooleanArrayWhereCondition, type BooleanWhereCondition, type ContextAPI, type DateArrayQueryWhereCondition, type DateArrayWhereCondition, type DateQueryInput, type DateWhereCondition, Duration, type DurationString, type DurationWhereCondition, ErrorPresets, type Errors, type ExtractStageKeys, File, type FlowConfig, type FlowContext, type FlowFunction, type FuncWithConfig, type FunctionConfig, type IDWhereCondition, InlineFile, ModelAPI, type NumberArrayQueryWhereCondition, type NumberArrayWhereCondition, type NumberWhereCondition, PERMISSION_STATE, type PageInfo, Permissions, type RelativeDateString, RequestHeaders, type Response, type SortDirection, type Step, type StringArrayQueryWhereCondition, type StringArrayWhereCondition, type StringWhereCondition, type TimestampQueryInput, type UI, type UIApiResponses, checkBuiltInPermissions, createFlowContext, handleFlow, handleJob, handleRequest, handleRoute, handleSubscriber, ksuid, tracing, useDatabase };