@niledatabase/server 5.0.0-alpha.0 → 5.0.0-alpha.10

package/dist/index.d.ts

@@ -1,5 +1,74 @@
 import pg, { PoolConfig, PoolClient } from 'pg';
 
+type LogFunction = (message: string | unknown, meta?: Record<string, unknown>) => void;
+type Loggable = {
+    info: LogFunction;
+    debug: LogFunction;
+    warn: LogFunction;
+    error: LogFunction;
+};
+type LogReturn = (prefixes?: string | string[]) => Loggable;
+
+type ExtensionCtx = {
+    handleOnRequest: (config: Config, _init: RequestInit & {
+        request: Request;
+    }, params: RequestInit) => Promise<void>;
+};
+type ConfigConstructor = NileConfig & {
+    extensionCtx?: ExtensionCtx;
+};
+declare class Config {
+    routes: Routes;
+    handlers: {
+        GET: (req: Request) => Promise<void | Response>;
+        POST: (req: Request) => Promise<void | Response>;
+        DELETE: (req: Request) => Promise<void | Response>;
+        PUT: (req: Request) => Promise<void | Response>;
+    };
+    paths: {
+        get: string[];
+        post: string[];
+        delete: string[];
+        put: string[];
+    };
+    extensionCtx: ExtensionCtx;
+    extensions?: Extension[];
+    logger: LogReturn;
+    /**
+     * Stores the set tenant id from Server for use in sub classes
+     */
+    tenantId: string | null | undefined;
+    /**
+     * Stores the set user id from Server for use in sub classes
+     */
+    userId: string | null | undefined;
+    /**
+     * Stores the headers to be used in `fetch` calls
+     */
+    headers: Headers;
+    /**
+     * The nile-auth url
+     */
+    apiUrl: string;
+    origin?: string | undefined | null;
+    /**
+     * important for separating the `origin` config value from a default in order to make requests
+     */
+    serverOrigin: string;
+    debug?: boolean;
+    /**
+     * To use secure cookies or not in the fetch
+     */
+    secureCookies?: boolean;
+    callbackUrl?: string;
+    /**
+     * change the starting route
+     */
+    routePrefix: string;
+    db: NilePoolConfig;
+    constructor(config?: ConfigConstructor);
+}
+
 type Routes = {
     SIGNIN: string;
     SESSION: string;
@@ -9,6 +78,7 @@ type Routes = {
     SIGNOUT: string;
     ERROR: string;
     ME: string;
+    USER_TENANTS: string;
     USERS: string;
     TENANTS: string;
     TENANT: string;
@@ -18,83 +88,11 @@ type Routes = {
     VERIFY_REQUEST: string;
     PASSWORD_RESET: string;
     LOG: string;
+    VERIFY_EMAIL: string;
+    INVITES: string;
+    INVITE: string;
 };
 
-type ApiParams = {
-    basePath?: string | undefined;
-    cookieKey?: string;
-    token?: string | undefined;
-    callbackUrl?: string | undefined;
-    routes?: Partial<Routes>;
-    routePrefix?: string | undefined;
-    secureCookies?: boolean;
-    origin?: null | undefined | string;
-};
-declare class ApiConfig {
-    #private;
-    cookieKey?: string;
-    basePath?: string | undefined;
-    routes?: Partial<Routes>;
-    routePrefix?: string;
-    secureCookies?: boolean;
-    origin?: string | null;
-    /**
-     * The client side callback url. Defaults to nothing (so nile.origin will be it), but in the cases of x-origin, you want to set this explicitly to be sure nile-auth does the right thing
-     * If this is set, any `callbackUrl` from the client will be ignored.
-     */
-    callbackUrl?: string;
-    constructor(config?: ServerConfig, logger?: string);
-    get token(): string | undefined;
-    set token(value: string | undefined);
-}
-declare class Config {
-    #private;
-    user: string;
-    password: string;
-    databaseId: string;
-    databaseName: string;
-    logger?: LoggerType;
-    debug: boolean;
-    db: NilePoolConfig;
-    api: ApiConfig;
-    get tenantId(): string | undefined | null;
-    set tenantId(value: string | undefined | null);
-    get userId(): string | undefined | null;
-    set userId(value: string | undefined | null);
-    constructor(config?: ServerConfig, logger?: string);
-}
-
-type Opts = {
-    basePath?: string;
-    fetch?: typeof fetch;
-};
-type NilePoolConfig = PoolConfig & {
-    afterCreate?: AfterCreate;
-};
-type LoggerType = {
-    info?: (args: unknown | unknown[]) => void;
-    warn?: (args: unknown | unknown[]) => void;
-    error?: (args: unknown | unknown[]) => void;
-    debug?: (args: unknown | unknown[]) => void;
-};
-type ServerConfig = {
-    databaseId?: string;
-    user?: string;
-    password?: string;
-    databaseName?: string;
-    tenantId?: string | null | undefined;
-    userId?: string | null | undefined;
-    debug?: boolean;
-    configureUrl?: string;
-    db?: NilePoolConfig;
-    api?: ApiParams;
-    logger?: LoggerType;
-};
-type NileDb = NilePoolConfig & {
-    tenantId?: string;
-};
-type AfterCreate = (conn: PoolClient, done: (err: null | Error, conn: PoolClient) => void) => void;
-
 interface CreateBasicUserRequest {
     email: string;
     password: string;
@@ -139,22 +137,111 @@ interface User {
     created: string;
     updated?: string;
     emailVerified?: string | null;
-    tenants: {
-        id: string;
-    }[];
+    tenants: string[];
+}
+
+declare class Users {
+    #private;
+    constructor(config: Config);
+    updateSelf<T = User[] | Response>(req: Partial<Omit<User, 'email' | 'tenants' | 'created' | 'updated' | 'emailVerified'> & {
+        emailVerified: boolean;
+    }>, rawResponse?: boolean): Promise<T>;
+    removeSelf(): Promise<Response>;
+    getSelf<T = User | Response>(): Promise<T>;
+    getSelf(rawResponse?: true): Promise<Response>;
+    verifySelf<T = void>(): Promise<T>;
+    verifySelf(rawResponse: true): Promise<Response>;
+    verifySelf<T = Response | User>(options: {
+        bypassEmail?: boolean;
+        callbackUrl?: string;
+    }, rawResponse?: true): Promise<T>;
 }
 
 type Tenant = {
     id: string;
     name: string;
 };
+type Invite = {
+    id: string;
+    tenant_id: string;
+    token: string;
+    identifier: string;
+    roles: null | string;
+    created_by: string;
+    expires: Date;
+};
 
+type ReqContext = {
+    userId?: string;
+    tenantId?: string;
+};
+type JoinTenantRequest = string | ReqContext | {
+    id: string;
+};
+declare class Tenants {
+    #private;
+    constructor(config: Config);
+    create(name: string, rawResponse: true): Promise<Response>;
+    create<T = Tenant | Response>(name: string, rawResponse?: boolean): Promise<T>;
+    create<T = Tenant | Response>(payload: {
+        name: string;
+        id?: string;
+    }, rawResponse?: boolean): Promise<T>;
+    delete<T = Response>(id?: string): Promise<T>;
+    delete<T = Response>(payload: {
+        id: string;
+    }): Promise<T>;
+    get<T = Tenant | Response>(): Promise<T>;
+    get<T = Tenant | Response>(id: string, rawResponse?: boolean): Promise<T>;
+    get(rawResponse: true): Promise<Response>;
+    get<T = Tenant | Response>(payload: {
+        id: string;
+    }, rawResponse?: boolean): Promise<T>;
+    update(req: Partial<Tenant>, rawResponse: true): Promise<Response>;
+    update<T = Tenant | Response | undefined>(req: Partial<Tenant>, rawResponse?: boolean): Promise<T>;
+    list<T = Tenant[] | Response>(): Promise<T>;
+    list(rawResponse: true): Promise<Response>;
+    leaveTenant<T = Response>(req?: string | {
+        tenantId: string;
+    }): Promise<T>;
+    addMember(req: JoinTenantRequest, rawResponse: true): Promise<Response>;
+    addMember<T = User | Response>(req: JoinTenantRequest, rawResponse?: boolean): Promise<T>;
+    removeMember(req: JoinTenantRequest, rawResponse?: boolean): Promise<Response>;
+    users<T = User[] | Response>(req?: boolean | {
+        tenantId?: string;
+    }, rawResponse?: boolean): Promise<T>;
+    users(req: true): Promise<Response>;
+    invites<T = Invite[] | Response>(): Promise<T>;
+    invite<T = Response | Invite>(req: string | {
+        email: string;
+        callbackUrl?: string;
+        redirectUrl?: string;
+    }, rawResponse?: boolean): Promise<T>;
+    invite(req: string | {
+        email: string;
+        callbackUrl?: string;
+        redirectUrl?: string;
+    }, rawResponse: true): Promise<Response>;
+    acceptInvite<T = Response>(req?: {
+        identifier: string;
+        token: string;
+        redirectUrl?: string;
+    }, rawResponse?: boolean): Promise<T>;
+    deleteInvite<T = Response>(req: string | {
+        id: string;
+    }): Promise<T>;
+}
+
+type ProviderName = 'discord' | 'github' | 'google' | 'hubspot' | 'linkedin' | 'slack' | 'twitter' | 'email' | 'credentials' | 'azure';
+type Providers = {
+    [providerName in ProviderName]: Provider;
+};
 type Provider = {
     id: string;
     name: string;
     type: string;
     signinUrl: string;
-    callbackUr: string;
+    callbackUrl: string;
 };
 type JWT = {
     email: string;
@@ -177,6 +264,236 @@ type ActiveSession = {
     };
 };
 
+type SignUpPayload = {
+    email: string;
+    password: string;
+    tenantId?: string;
+    newTenantName?: string;
+};
+declare class Auth {
+    #private;
+    constructor(config: Config);
+    getSession<T = JWT | ActiveSession | undefined>(rawResponse?: false): Promise<T>;
+    getSession(rawResponse: true): Promise<Response>;
+    getCsrf<T = Response | JSON>(rawResponse?: false): Promise<T>;
+    getCsrf(rawResponse: true): Promise<Response>;
+    listProviders(rawResponse: true): Promise<Response>;
+    listProviders<T = {
+        [key: string]: Provider;
+    }>(rawResponse?: false): Promise<T>;
+    signOut(): Promise<Response>;
+    /**
+     * signUp only works with email + password
+     * @param payload
+     * @param rawResponse
+     */
+    signUp(payload: SignUpPayload, rawResponse: true): Promise<Response>;
+    signUp<T = User | Response>(payload: SignUpPayload): Promise<T>;
+    forgotPassword(req: {
+        email: string;
+        callbackUrl?: string;
+        redirectUrl?: string;
+    }): Promise<Response>;
+    resetPassword(req: Request | {
+        email: string;
+        password: string;
+        callbackUrl?: string;
+        redirectUrl?: string;
+    }): Promise<Response>;
+    callback(provider: ProviderName, body?: string | Request): Promise<Response>;
+    /**
+     * The return value from this will be a redirect for the client
+     * In most cases, you should forward the response directly to the client
+     * @param payload
+     * @param rawResponse
+     */
+    signIn<T = Response>(provider: ProviderName, payload?: Request | {
+        email: string;
+        password: string;
+    }, rawResponse?: true): Promise<T>;
+}
+declare function parseCSRF(headers?: Headers): string | undefined;
+declare function parseCallback(headers?: Headers): string | undefined;
+declare function parseToken(headers?: Headers): string | undefined;
+
+type CTXHandlerType = {
+    GET: (req: Request) => Promise<{
+        response: void | Response;
+        nile: Server;
+    }>;
+    POST: (req: Request) => Promise<{
+        response: void | Response;
+        nile: Server;
+    }>;
+    DELETE: (req: Request) => Promise<{
+        response: void | Response;
+        nile: Server;
+    }>;
+    PUT: (req: Request) => Promise<{
+        response: void | Response;
+        nile: Server;
+    }>;
+};
+
+declare class Server {
+    #private;
+    users: Users;
+    tenants: Tenants;
+    auth: Auth;
+    constructor(config?: NileConfig);
+    get db(): pg.Pool & {
+        clearConnections: () => void;
+    };
+    /**
+     * A convenience function that applies a config and ensures whatever was passed is set properly
+     */
+    getInstance<T = Request | Headers | Record<string, string>>(config: NileConfig, req?: T): Server;
+    getPaths(): {
+        get: string[];
+        post: string[];
+        delete: string[];
+        put: string[];
+    };
+    get handlers(): {
+        GET: (req: Request) => Promise<void | Response>;
+        POST: (req: Request) => Promise<void | Response>;
+        DELETE: (req: Request) => Promise<void | Response>;
+        PUT: (req: Request) => Promise<void | Response>;
+        withContext: CTXHandlerType;
+    };
+    /**
+     * Allow the setting of headers from a req or header object.
+     * Makes it possible to handle REST requests easily
+     * Also makes it easy to set user + tenant in some way
+     * @param req
+     * @returns undefined
+     */
+    setContext(req: Request | Headers | Record<string, string> | unknown | {
+        tenantId?: string;
+        userId?: string;
+    }): void;
+    getContext(): {
+        headers: Headers | undefined;
+        userId: string | null | undefined;
+        tenantId: string | null | undefined;
+        preserveHeaders: boolean;
+    };
+}
+declare function create(config?: NileConfig): Server;
+
+type Opts = {
+    basePath?: string;
+    fetch?: typeof fetch;
+};
+interface ExtensionResult {
+    id?: string;
+    [key: string]: unknown;
+    onRequest?: (req: Request) => void | Promise<void | RequestInit>;
+    onResponse?: (res: Response) => void | Promise<void>;
+}
+type Extension = (instance: Server) => ExtensionResult | Promise<ExtensionResult>;
+type NilePoolConfig = PoolConfig & {
+    afterCreate?: AfterCreate;
+};
+type LoggerType = {
+    info: (args: unknown | unknown[]) => void;
+    warn: (args: unknown | unknown[]) => void;
+    error: (args: unknown | unknown[]) => void;
+    debug: (args: unknown | unknown[]) => void;
+};
+type NileConfig = {
+    /**
+     * The specific database id. Either passed in or figured out by NILEDB_API_URL
+     * process.env.NILEDB_ID
+     */
+    databaseId?: string;
+    /**
+     * The user UUID to the database
+     * process.env.NILEDB_USER
+     */
+    user?: string;
+    /**
+     * The password UUID to the database
+     * process.env.NILEDB_PASSWORD
+     */
+    password?: string;
+    /**
+     * The name of the database. Automatically obtained from NILEDB_POSTGRES_URL
+     * process.env.NILEDB_NAME
+     */
+    databaseName?: string;
+    /**
+     * A tenant id. Scopes requests to a specific tenant, both API and DB
+     * process.env.NILEDB_TENANT
+     */
+    tenantId?: string | null | undefined;
+    /**
+     * A user id. Possibly not the logged in user, used for setting database context (nile.user_id)
+     * Generally speaking, this wouldn't be used for authentication, and in some cases simply won't do anything on some endpoints
+     */
+    userId?: string | null | undefined;
+    /**
+     * Shows a bunch of logging on the server side to see what's being done between the sdk and nile-auth
+     */
+    debug?: boolean;
+    /**
+     * DB configuration overrides. Environment variables are the way to go, but maybe you need something more
+     */
+    db?: NilePoolConfig;
+    /**
+     * Some kind of logger if you want to send to an external service
+     */
+    logger?: LogReturn;
+    /**
+     * The configuration value that maps to `NILEDB_API_URL` - its going to be nile-auth (or similar service)
+     */
+    apiUrl?: string | undefined;
+    /**
+     * Ignore client callbackUrls by setting this.
+     * You can force the callback URL server side to be sure nile-auth redirects to whatever location.
+     */
+    callbackUrl?: string | undefined;
+    /**
+     * Need to override some routes? Change it here
+     */
+    routes?: Partial<Routes>;
+    /**
+     * don't like the default `/api`? change it here
+     */
+    routePrefix?: string | undefined;
+    /**
+     * In some cases, you may want to force secure cookies.
+     * The SDK handles this for you, but might be necessary in some firewall / internal cases
+     * Defaults to true if you're in production
+     */
+    secureCookies?: boolean;
+    /**
+     * The origin for the requests.
+     * Allows the setting of the callback origin to a random FE
+     * eg FE localhost:3001 -> BE: localhost:5432 would set to localhost:3001 to be sure nile-auth uses that.
+     * In full stack cases, will just be the `host` header of the incoming request, which is used by default
+     * It is also important to set this when dealing with secure cookies. Calling via server side needs to know if TLS is being used so that nile-auth knows which cookies to be sent.
+     */
+    origin?: null | undefined | string;
+    /**
+     * Set the headers to use in API requests.
+     * The `cookie` would be expected if you are setting this, else most calls will be unauthorized
+     */
+    headers?: null | Headers | Record<string, string>;
+    /**
+     * Functions to run at various points to make life easier
+     */
+    extensions?: Extension[];
+    /**
+     * In some cases, like when using REST context, we want to preserve the headers from the request,
+     * regardless of what an extension might do
+     */
+    preserveHeaders?: boolean;
+};
+type NileDb = NilePoolConfig & {
+    tenantId?: string;
+};
+type AfterCreate = (conn: PoolClient, done: (err: null | Error, conn: PoolClient) => void) => void;
 interface NileBody<R, B> {
     readonly body: ReadableStream<Uint8Array> | null | B;
     readonly bodyUsed: boolean;
@@ -186,6 +503,16 @@ interface NileBody<R, B> {
     json(): Promise<R>;
     text(): Promise<string>;
 }
+interface NResponse<T> extends NileBody<T, any> {
+    readonly headers: Headers;
+    readonly ok: boolean;
+    readonly redirected: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly type: ResponseType;
+    readonly url: string;
+    clone(): Response;
+}
 interface NRequest<T> extends NileBody<any, T> {
     /** Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching. */
     readonly cache: RequestCache;
@@ -216,132 +543,48 @@ interface NRequest<T> extends NileBody<any, T> {
     clone(): Request;
 }
 type NileRequest<T> = NRequest<T> | T;
-
-declare class Auth extends Config {
-    headers?: Headers;
-    resetHeaders?: (headers?: Headers) => void;
-    constructor(config: Config, headers?: Headers, params?: {
-        resetHeaders: () => void;
-    });
-    handleHeaders(init?: RequestInit): RequestInit | undefined;
-    get sessionUrl(): string;
-    getSession: <T = JWT | ActiveSession | Response | undefined>(req: NileRequest<void> | Headers, init?: RequestInit) => Promise<T>;
-    get getCsrfUrl(): string;
-    getCsrf<T = Response | JSON>(req: NileRequest<void> | Headers, init?: RequestInit, raw?: boolean): Promise<T>;
-    get listProvidersUrl(): string;
-    listProviders: <T = Response | {
-        [key: string]: Provider;
-    }>(req: NileRequest<void> | Headers, init?: RequestInit) => Promise<T>;
-    get signOutUrl(): string;
-    signOut: <T = Response | {
-        url: string;
-    }>(req: NileRequest<void | {
-        callbackUrl?: string;
-    }> | Headers, init?: RequestInit) => Promise<T>;
-}
-
-declare class Tenants extends Config {
-    headers?: Headers;
-    constructor(config: Config, headers?: Headers);
-    handleHeaders(init?: RequestInit): RequestInit | undefined;
-    get tenantsUrl(): string;
-    get tenantUrl(): string;
-    createTenant: <T = Tenant | Response>(req: NileRequest<{
-        name: string;
-        id?: string;
-    }> | Headers | string, init?: RequestInit) => Promise<T>;
-    getTenant: <T = Tenant | Response>(req: NileRequest<{
-        id: string;
-    }> | Headers | string | void, init?: RequestInit) => Promise<T>;
-    get tenantListUrl(): string;
-    listTenants: <T = Tenant[] | Response>(req: NileRequest<void> | Headers, init?: RequestInit) => Promise<T>;
-    deleteTenant: <T = Response>(req: NileRequest<void> | Headers | string, init?: RequestInit) => Promise<T>;
-    updateTenant: <T = Tenant | Response>(req: NileRequest<void> | Headers | {
-        name: string;
-    }, init?: RequestInit) => Promise<T>;
-}
-
-declare class Users extends Config {
-    headers?: Headers;
-    constructor(config: Config, headers?: Headers);
-    usersUrl(user: CreateBasicUserRequest): string;
-    get tenantUsersUrl(): string;
-    get linkUsersUrl(): string;
-    get tenantUserUrl(): string;
-    handleHeaders(init?: RequestInit): RequestInit | undefined;
-    createUser: <T = User | Response>(user: CreateBasicUserRequest, init?: RequestInit) => Promise<T>;
-    createTenantUser: <T = User | Response>(req: NileRequest<CreateTenantUserRequest>, init?: RequestInit) => Promise<T>;
-    updateUser: <T = User[] | Response>(req: NileRequest<Partial<Omit<User, "email" | "tenants" | "created" | "updated">>>, init?: RequestInit) => Promise<T>;
-    listUsers: <T = User[] | Response>(req: NileRequest<void> | Headers, init?: RequestInit) => Promise<T>;
-    linkUser: <T = User | Response>(req: NileRequest<{
-        id: string;
-        tenantId?: string;
-    }> | Headers | string, init?: RequestInit) => Promise<T>;
-    unlinkUser: <T = Response>(req: NileRequest<{
-        id: string;
-        tenantId?: string;
-    }> | Headers | string, init?: RequestInit) => Promise<T>;
-    get meUrl(): string;
-    me: <T = User | Response>(req: NileRequest<void> | Headers, init?: RequestInit) => Promise<T>;
-    updateMe: <T = User | Response>(req: NileRequest<Partial<Omit<User, "email" | "id" | "tenants" | "created" | "updated">>> | Headers, init?: RequestInit) => Promise<T>;
-}
-
-declare class Api {
-    #private;
-    config: Config;
-    users: Users;
-    auth: Auth;
-    tenants: Tenants;
-    routes: Routes;
-    handlers: {
-        GET: (req: Request) => Promise<void | Response>;
-        POST: (req: Request) => Promise<void | Response>;
-        DELETE: (req: Request) => Promise<void | Response>;
-        PUT: (req: Request) => Promise<void | Response>;
-    };
-    paths: {
-        get: string[];
-        post: string[];
-        delete: string[];
-        put: string[];
-    };
-    constructor(config: Config);
-    reset: () => void;
-    updateConfig: (config: Config) => void;
-    resetHeaders: (headers?: Headers) => void;
-    set headers(headers: Headers | Record<string, string>);
-    get headers(): Headers | undefined;
-    getCookie(req?: Request | Headers): string | null | undefined;
-    login: (payload: {
-        email: string;
-        password: string;
-    }, config?: {
-        returnResponse?: boolean;
-    }) => Promise<Response | undefined>;
-    session: (req?: Request | Headers | null | undefined) => Promise<Response | JWT | ActiveSession | null | undefined>;
-    setContext: (req: Request | Headers | Record<string, string>) => void;
-}
-
-declare class Server {
-    config: Config;
-    api: Api;
-    private manager;
-    constructor(config?: ServerConfig);
-    setConfig(cfg: Config): void;
-    set databaseId(val: string | void);
-    get userId(): string | undefined | null;
-    set userId(userId: string | undefined | null);
-    get tenantId(): string | undefined | null;
-    set tenantId(tenantId: string | undefined | null);
-    get token(): string | undefined | null;
-    set token(token: string | undefined | null);
-    get db(): pg.Pool;
-    clearConnections(): void;
+declare const APIErrorErrorCodeEnum: {
+    readonly InternalError: "internal_error";
+    readonly BadRequest: "bad_request";
+    readonly EntityNotFound: "entity_not_found";
+    readonly DuplicateEntity: "duplicate_entity";
+    readonly InvalidCredentials: "invalid_credentials";
+    readonly UnknownOidcProvider: "unknown_oidc_provider";
+    readonly ProviderAlreadyExists: "provider_already_exists";
+    readonly ProviderConfigError: "provider_config_error";
+    readonly ProviderMismatch: "provider_mismatch";
+    readonly ProviderUpdateError: "provider_update_error";
+    readonly SessionStateMissing: "session_state_missing";
+    readonly SessionStateMismatch: "session_state_mismatch";
+    readonly OidcCodeMissing: "oidc_code_missing";
+};
+type APIErrorErrorCodeEnum = (typeof APIErrorErrorCodeEnum)[keyof typeof APIErrorErrorCodeEnum];
+interface APIError {
+    [key: string]: any | any;
     /**
-     * A convenience function that applies a config and ensures whatever was passed is set properly
+     *
+     * @type {string}
+     * @memberof APIError
+     */
+    errorCode: APIErrorErrorCodeEnum;
+    /**
+     *
+     * @type {string}
+     * @memberof APIError
+     */
+    message: string;
+    /**
+     *
+     * @type {number}
+     * @memberof APIError
      */
-    getInstance(config: ServerConfig): Server;
+    statusCode: number;
 }
-declare function create(config?: ServerConfig): Server;
+type NileResponse<T> = Promise<T | NResponse<T & APIError>>;
+
+declare const TENANT_COOKIE = "nile.tenant-id";
+declare const USER_COOKIE = "nile.user-id";
+declare const HEADER_ORIGIN = "nile-origin";
+declare const HEADER_SECURE_COOKIES = "nile-secure-cookies";
 
-export { type ActiveSession, type AfterCreate, type CreateBasicUserRequest, type CreateTenantUserRequest, type JWT, type LoggerType, type LoginUserResponse, type LoginUserResponseToken, LoginUserResponseTokenTypeEnum, create as Nile, type NileDb, type NilePoolConfig, type Opts, Server, type ServerConfig, type Tenant, type User };
+export { type APIError, APIErrorErrorCodeEnum, type ActiveSession, type AfterCreate, type CreateBasicUserRequest, type CreateTenantUserRequest, type Extension, type ExtensionResult, HEADER_ORIGIN, HEADER_SECURE_COOKIES, type Invite, type JWT, type LoggerType, type LoginUserResponse, type LoginUserResponseToken, LoginUserResponseTokenTypeEnum, create as Nile, type NileConfig, type NileDb, type NilePoolConfig, type NileRequest, type NileResponse, type Opts, type Providers, Server, TENANT_COOKIE, type Tenant, USER_COOKIE, type User, parseCSRF, parseCallback, parseToken };