Extend PocketBun Reference

declare var __hooks: string;

declare var $app: PocketBase;

declare var $template: template.Registry;

declare const Record: {
  new (collection?: core.Collection, data?: { [key: string]: any }): core.Record;

  // note: declare as "newable" const due to conflict with the Record TS utility type
};

declare const RequestInfo: {
  new (info?: Partial<core.RequestInfo>): core.RequestInfo;

  // note: declare as "newable" const due to conflict with the RequestInfo TS node type
};

declare function cronAdd(jobId: string, cronExpr: string, handler: () => void): void;

declare function cronRemove(jobId: string): void;

declare function routerAdd(
  method: string,
  path: string,
  handler: (e: core.RequestEvent) => void,
  ...middlewares: Array<string | ((e: core.RequestEvent) => void) | Middleware>
): void;

declare function routerUse(...middlewares: Array<string | ((e: core.RequestEvent) => void) | Middleware>): void;

declare function readerToString(reader: any, maxBytes?: number): string;

declare function toString(val: any, maxBytes?: number): string;

declare function toBytes(val: any, maxBytes?: number): Array<number>;

declare function sleep(milliseconds: number): void;

declare function arrayOf<T>(model: T): Array<T>;

declare function nullString(): string;

declare function nullInt(): number;

declare function nullFloat(): number;

declare function nullBool(): boolean;

declare function nullArray(): Array<any>;

declare function nullObject(): { get(key: string): any; set(key: string, value: any): void };

declare function migrate(up: (txApp: CoreApp) => void, down?: (txApp: CoreApp) => void): void;

declare class DynamicModel {
  [key: string]: any;
  constructor(shape?: { [key: string]: any });
}

declare class Context implements context.Context {
  constructor(parentCtx?: Context, key?: any, value?: any);
}

declare class Collection implements core.Collection {
  constructor(data?: Partial<Collection>);
}

declare class FieldsList implements core.FieldsList {
  constructor(data?: Partial<core.FieldsList>);
}

declare class Field implements core.Field {
  constructor(data?: Partial<core.Field>);
}

declare class NumberField implements core.NumberField {
  constructor(data?: Partial<core.NumberField>);
}

declare class BoolField implements core.BoolField {
  constructor(data?: Partial<core.BoolField>);
}

declare class TextField implements core.TextField {
  constructor(data?: Partial<core.TextField>);
}

declare class URLField implements core.URLField {
  constructor(data?: Partial<core.URLField>);
}

declare class EmailField implements core.EmailField {
  constructor(data?: Partial<core.EmailField>);
}

declare class EditorField implements core.EditorField {
  constructor(data?: Partial<core.EditorField>);
}

declare class PasswordField implements core.PasswordField {
  constructor(data?: Partial<core.PasswordField>);
}

declare class DateField implements core.DateField {
  constructor(data?: Partial<core.DateField>);
}

declare class AutodateField implements core.AutodateField {
  constructor(data?: Partial<core.AutodateField>);
}

declare class JSONField implements core.JSONField {
  constructor(data?: Partial<core.JSONField>);
}

declare class RelationField implements core.RelationField {
  constructor(data?: Partial<core.RelationField>);
}

declare class SelectField implements core.SelectField {
  constructor(data?: Partial<core.SelectField>);
}

declare class FileField implements core.FileField {
  constructor(data?: Partial<core.FileField>);
}

declare class GeoPointField implements core.GeoPointField {
  constructor(data?: Partial<core.GeoPointField>);
}

declare class MailerMessage implements mailer.Message {
  constructor(message?: Partial<mailer.Message>);
}

declare class Command implements cobra.Command {
  constructor(cmd?: Partial<cobra.Command>);
}

declare class Middleware {
  constructor(func: string | ((e: core.RequestEvent) => void), priority?: number, id?: string);
}

declare class Timezone implements time.Location {
  constructor(name?: string);
}

declare class DateTime implements types.DateTime {
  constructor(date?: string, defaultParseInLocation?: string);
}

declare class ValidationError implements ozzo_validation.Error {
  constructor(code?: string, message?: string);
}

declare class Cookie implements http.Cookie {
  constructor(options?: Partial<http.Cookie>);
}

declare class SubscriptionMessage implements subscriptions.Message {
  constructor(options?: Partial<subscriptions.Message>);
}

declare class AppleClientSecretCreateForm implements forms.AppleClientSecretCreate {
  constructor(app: CoreApp);
}

declare class RecordUpsertForm implements forms.RecordUpsert {
  constructor(app: CoreApp, record: core.Record);
}

declare class TestEmailSendForm implements forms.TestEmailSend {
  constructor(app: CoreApp);
}

declare class TestS3FilesystemForm implements forms.TestS3Filesystem {
  constructor(app: CoreApp);
}

declare class ApiError implements router.ApiError {
  constructor(status?: number, message?: string, data?: any);
}

declare class NotFoundError implements router.ApiError {
  constructor(message?: string, data?: any);
}

declare class BadRequestError implements router.ApiError {
  constructor(message?: string, data?: any);
}

declare class ForbiddenError implements router.ApiError {
  constructor(message?: string, data?: any);
}

declare class UnauthorizedError implements router.ApiError {
  constructor(message?: string, data?: any);
}

declare class TooManyRequestsError implements router.ApiError {
  constructor(message?: string, data?: any);
}

declare class InternalServerError implements router.ApiError {
  constructor(message?: string, data?: any);
}

declare namespace $dbx {
  /**
   * {@inheritDoc dbx.HashExp}
   */
  export function hashExp(pairs: { [key: string]: any }): dbx.Expression;

  let _in: dbx._in;
  export { _in as in };

  export let exp: dbx.newExp;
  export let not: dbx.not;
  export let and: dbx.and;
  export let or: dbx.or;
  export let notIn: dbx.notIn;
  export let like: dbx.like;
  export let orLike: dbx.orLike;
  export let notLike: dbx.notLike;
  export let orNotLike: dbx.orNotLike;
  export let exists: dbx.exists;
  export let notExists: dbx.notExists;
  export let between: dbx.between;
  export let notBetween: dbx.notBetween;
}

declare namespace $mails {
  let sendRecordPasswordReset: mails.sendRecordPasswordReset;
  let sendRecordVerification: mails.sendRecordVerification;
  let sendRecordChangeEmail: mails.sendRecordChangeEmail;
  let sendRecordOTP: mails.sendRecordOTP;
  let sendRecordAuthAlert: mails.sendRecordAuthAlert;
}

declare namespace $security {
  let randomString: security.randomString;
  let randomStringWithAlphabet: security.randomStringWithAlphabet;
  let randomStringByRegex: security.randomStringByRegex;
  let pseudorandomString: security.pseudorandomString;
  let pseudorandomStringWithAlphabet: security.pseudorandomStringWithAlphabet;
  let encrypt: security.encrypt;
  let decrypt: security.decrypt;
  let hs256: security.hs256;
  let hs512: security.hs512;
  let equal: security.equal;
  let md5: security.md5;
  let sha256: security.sha256;
  let sha512: security.sha512;

  /**
   * {@inheritDoc security.newJWT}
   */
  export function createJWT(payload: { [key: string]: any }, signingKey: string, secDuration: number): string;

  /**
   * {@inheritDoc security.parseUnverifiedJWT}
   */
  export function parseUnverifiedJWT(token: string): { [key: string]: any };

  /**
   * {@inheritDoc security.parseJWT}
   */
  export function parseJWT(token: string, verificationKey: string): { [key: string]: any };
}

declare namespace $filesystem {
  let fileFromPath: filesystem.newFileFromPath;
  /**
   * PocketBun-only async variant of fileFromPath.
   */
  export function fileFromPathAsync(path: string): Promise<filesystem.File>;
  let fileFromBytes: filesystem.newFileFromBytes;
  let fileFromMultipart: filesystem.newFileFromMultipart;

  /**
   * Initializes a new S3-only filesystem instance
   * (make sure to call `close()` after you are done working with it).
   *
   * Most users should prefer `$app.newFilesystem()` which will
   * construct a local or S3 filesystem based on the configured application settings.
   */
  let s3: filesystem.newS3;

  /**
   * Initializes a new local-only filesystem instance
   * (make sure to call `close()` after you are done working with it).
   *
   * Most users should prefer `$app.newFilesystem()` which will
   * construct a local or S3 filesystem based on the configured application settings.
   */
  let local: filesystem.newLocal;

  /**
   * fileFromURL creates a new File from the provided url by
   * downloading the resource and creating a BytesReader.
   *
   * Example:
   *
   * ```js
   * // with default max timeout of 120sec
   * const file1 = $filesystem.fileFromURL("https://...")
   *
   * // with custom timeout of 15sec
   * const file2 = $filesystem.fileFromURL("https://...", 15)
   * ```
   */
  export function fileFromURL(url: string, secTimeout?: number): filesystem.File;
  /**
   * PocketBun-only async variant of fileFromURL.
   */
  export function fileFromURLAsync(url: string, secTimeout?: number): Promise<filesystem.File>;
}

declare namespace $filepath {
  export let base: filepath.base;
  export let clean: filepath.clean;
  export let dir: filepath.dir;
  export let ext: filepath.ext;
  export let fromSlash: filepath.fromSlash;
  export let glob: filepath.glob;
  export let isAbs: filepath.isAbs;
  export let join: filepath.join;
  export let match: filepath.match;
  export let rel: filepath.rel;
  export let split: filepath.split;
  export let splitList: filepath.splitList;
  export let toSlash: filepath.toSlash;
  export let walk: filepath.walk;
  export let walkDir: filepath.walkDir;
}

declare namespace $os {
  /**
   * Legacy alias for $os.cmd().
   */
  export let exec: exec.command;

  /**
   * Prepares an external OS command.
   *
   * Example:
   *
   * ```js
   * // prepare the command to execute
   * const cmd = $os.cmd('ls', '-sl')
   *
   * // execute the command and return its standard output as string
   * const output = toString(cmd.output());
   * ```
   */
  export let cmd: exec.command;

  /**
   * Args hold the command-line arguments, starting with the program name.
   */
  export let args: Array<string>;

  export let exit: os.exit;
  export let getenv: os.getenv;
  export let dirFS: os.dirFS;
  export let readFile: os.readFile;
  export function readFileAsync(name: string): Promise<string | Array<number>>;
  export let writeFile: os.writeFile;
  export function writeFileAsync(name: string, data: string | Array<number>): Promise<void>;
  export let stat: os.stat;
  export function statAsync(name: string): Promise<unknown>;
  export let readDir: os.readDir;
  export function readDirAsync(name: string): Promise<Array<unknown>>;
  export let tempDir: os.tempDir;
  export let truncate: os.truncate;
  export function truncateAsync(name: string, size: number): Promise<void>;
  export let getwd: os.getwd;
  export let mkdir: os.mkdir;
  export function mkdirAsync(name: string): Promise<void>;
  export let mkdirAll: os.mkdirAll;
  export function mkdirAllAsync(path: string): Promise<void>;
  export let rename: os.rename;
  export function renameAsync(oldpath: string, newpath: string): Promise<void>;
  export let remove: os.remove;
  export function removeAsync(path: string): Promise<void>;
  export let removeAll: os.removeAll;
  export function removeAllAsync(path: string): Promise<void>;
  export let openRoot: os.openRoot;
  export let openInRoot: os.openInRoot;
}

declare namespace $apis {
  /**
   * Route handler to serve static directory content (html, js, css, etc.).
   *
   * If a file resource is missing and indexFallback is set, the request
   * will be forwarded to the base index.html (useful for SPA).
   */
  export function static(dir: string, indexFallback: boolean): (e: core.RequestEvent) => void;

  let requireGuestOnly: apis.requireGuestOnly;
  let requireAuth: apis.requireAuth;
  let requireSuperuserAuth: apis.requireSuperuserAuth;
  let requireSuperuserOrOwnerAuth: apis.requireSuperuserOrOwnerAuth;
  let skipSuccessActivityLog: apis.skipSuccessActivityLog;
  let gzip: apis.gzip;
  let bodyLimit: apis.bodyLimit;
  let enrichRecord: apis.enrichRecord;
  let enrichRecords: apis.enrichRecords;

  /**
   * RecordAuthResponse writes standardized json record auth response
   * into the specified request event.
   *
   * The authMethod argument specify the name of the current authentication method (eg. password, oauth2, etc.)
   * that it is used primarily as an auth identifier during MFA and for login alerts.
   *
   * Set authMethod to empty string if you want to ignore the MFA checks and the login alerts
   * (can be also adjusted additionally via the onRecordAuthRequest hook).
   */
  export function recordAuthResponse(e: core.RequestEvent, authRecord: core.Record, authMethod: string, meta?: any): void;
}

declare namespace $http {
  /**
   * Sends a single HTTP request.
   *
   * Example:
   *
   * ```js
   * const res = $http.send({
   *     method:  "POST",
   *     url:     "https://example.com",
   *     body:    JSON.stringify({"title": "test"}),
   *     headers: { 'Content-Type': 'application/json' }
   * })
   *
   * console.log(res.statusCode) // the response HTTP status code
   * console.log(res.headers)    // the response headers (eg. res.headers['X-Custom'][0])
   * console.log(res.cookies)    // the response cookies (eg. res.cookies.sessionId.value)
   * console.log(res.body)       // the response body as raw bytes slice
   * console.log(res.json)       // the response body as parsed json array or map
   * ```
   */
  function send(config: {
    url: string;
    body?: string | FormData;
    method?: string; // default to "GET"
    headers?: { [key: string]: string };
    timeout?: number; // default to 120

    // @deprecated please use body instead
    data?: { [key: string]: any };
  }): {
    statusCode: number;
    headers: { [key: string]: Array<string> };
    cookies: { [key: string]: http.Cookie };
    json: any;
    body: Array<number>;

    // @deprecated please use toString(result.body) instead
    raw: string;
  };

  /**
   * PocketBun-only async variant of send().
   */
  function sendAsync(config: {
    url: string;
    body?: string | FormData;
    method?: string; // default to "GET"
    headers?: { [key: string]: string };
    timeout?: number; // default to 120

    // @deprecated please use body instead
    data?: { [key: string]: any };
  }): Promise<{
    statusCode: number;
    headers: { [key: string]: Array<string> };
    cookies: { [key: string]: http.Cookie };
    json: any;
    body: Array<number>;

    // @deprecated please use toString(result.body) instead
    raw: string;
  }>;
}