@darseen/vaze 1.1.1 → 1.2.1

package/dist/index.d.ts

@@ -1,39 +1,721 @@
-import * as _repo_types from '@repo/types';
-import { ApiResponse, FileWithUrl, Folder } from '@repo/types';
-export { ApiResponse, FileWithUrl as File, Folder } from '@repo/types';
+declare const entityKind: unique symbol;
 
-declare class Base {
-    private apiKey;
-    protected vazeUrl: string;
-    constructor(options?: {
-        apiKey?: string;
-        vazeUrl?: string;
+declare class CasingCache {
+    static readonly [entityKind]: string;
+    private cachedTables;
+    private convert;
+    constructor(casing?: Casing);
+    getColumnCasing(column: Column): string;
+    private cacheTable;
+    clearCache(): void;
+}
+
+interface Subquery<TAlias extends string = string, TSelectedFields extends Record<string, unknown> = Record<string, unknown>> extends SQLWrapper {
+}
+declare class Subquery<TAlias extends string = string, TSelectedFields extends Record<string, unknown> = Record<string, unknown>> implements SQLWrapper {
+    static readonly [entityKind]: string;
+    _: {
+        brand: 'Subquery';
+        sql: SQL;
+        selectedFields: TSelectedFields;
+        alias: TAlias;
+        isWith: boolean;
+        usedTables?: string[];
+    };
+    constructor(sql: SQL, fields: TSelectedFields, alias: string, isWith?: boolean, usedTables?: string[]);
+}
+
+interface TableConfig$1<TColumn extends Column = Column<any>> {
+    name: string;
+    schema: string | undefined;
+    columns: Record<string, TColumn>;
+    dialect: string;
+}
+interface Table<T extends TableConfig$1 = TableConfig$1> extends SQLWrapper {
+}
+declare class Table<T extends TableConfig$1 = TableConfig$1> implements SQLWrapper {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly brand: 'Table';
+        readonly config: T;
+        readonly name: T['name'];
+        readonly schema: T['schema'];
+        readonly columns: T['columns'];
+        readonly inferSelect: InferSelectModel<Table<T>>;
+        readonly inferInsert: InferInsertModel<Table<T>>;
+    };
+    readonly $inferSelect: InferSelectModel<Table<T>>;
+    readonly $inferInsert: InferInsertModel<Table<T>>;
+    constructor(name: string, schema: string | undefined, baseName: string);
+}
+type MapColumnName<TName extends string, TColumn extends Column, TDBColumNames extends boolean> = TDBColumNames extends true ? TColumn['_']['name'] : TName;
+type InferModelFromColumns<TColumns extends Record<string, Column>, TInferMode extends 'select' | 'insert' = 'select', TConfig extends {
+    dbColumnNames: boolean;
+    override?: boolean;
+} = {
+    dbColumnNames: false;
+    override: false;
+}> = Simplify<TInferMode extends 'insert' ? {
+    [Key in keyof TColumns & string as RequiredKeyOnly<MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>, TColumns[Key]>]: GetColumnData<TColumns[Key], 'query'>;
+} & {
+    [Key in keyof TColumns & string as OptionalKeyOnly<MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>, TColumns[Key], TConfig['override']>]?: GetColumnData<TColumns[Key], 'query'> | undefined;
+} : {
+    [Key in keyof TColumns & string as MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>]: GetColumnData<TColumns[Key], 'query'>;
+}>;
+type InferSelectModel<TTable extends Table, TConfig extends {
+    dbColumnNames: boolean;
+} = {
+    dbColumnNames: false;
+}> = InferModelFromColumns<TTable['_']['columns'], 'select', TConfig>;
+type InferInsertModel<TTable extends Table, TConfig extends {
+    dbColumnNames: boolean;
+    override?: boolean;
+} = {
+    dbColumnNames: false;
+    override: false;
+}> = InferModelFromColumns<TTable['_']['columns'], 'insert', TConfig>;
+
+type JoinNullability = 'nullable' | 'not-null';
+type ApplyNullability<T, TNullability extends JoinNullability> = TNullability extends 'nullable' ? T | null : TNullability extends 'null' ? null : T;
+type ApplyNotNullMapToJoins<TResult, TNullabilityMap extends Record<string, JoinNullability>> = {
+    [TTableName in keyof TResult & keyof TNullabilityMap & string]: ApplyNullability<TResult[TTableName], TNullabilityMap[TTableName]>;
+} & {};
+type SelectMode = 'partial' | 'single' | 'multiple';
+type SelectResult<TResult, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = TSelectMode extends 'partial' ? SelectPartialResult<TResult, TNullabilityMap> : TSelectMode extends 'single' ? SelectResultFields<TResult> : ApplyNotNullMapToJoins<SelectResultFields<TResult>, TNullabilityMap>;
+type SelectPartialResult<TFields, TNullability extends Record<string, JoinNullability>> = TNullability extends TNullability ? {
+    [Key in keyof TFields]: TFields[Key] extends infer TField ? TField extends Table ? TField['_']['name'] extends keyof TNullability ? ApplyNullability<SelectResultFields<TField['_']['columns']>, TNullability[TField['_']['name']]> : never : TField extends Column ? TField['_']['tableName'] extends keyof TNullability ? ApplyNullability<SelectResultField<TField>, TNullability[TField['_']['tableName']]> : never : TField extends SQL | SQL.Aliased ? SelectResultField<TField> : TField extends Subquery ? FromSingleKeyObject<TField['_']['selectedFields'], TField['_']['selectedFields'] extends {
+        [key: string]: infer TValue;
+    } ? SelectResultField<TValue> : never, 'You can only select one column in the subquery'> : TField extends Record<string, any> ? TField[keyof TField] extends AnyColumn<{
+        tableName: infer TTableName extends string;
+    }> | SQL | SQL.Aliased ? Not<IsUnion<TTableName>> extends true ? ApplyNullability<SelectResultFields<TField>, TNullability[TTableName]> : SelectPartialResult<TField, TNullability> : never : never : never;
+} : never;
+type SelectResultField<T, TDeep extends boolean = true> = T extends DrizzleTypeError<any> ? T : T extends Table ? Equal<TDeep, true> extends true ? SelectResultField<T['_']['columns'], false> : never : T extends Column<any> ? GetColumnData<T> : T extends SQL | SQL.Aliased ? T['_']['type'] : T extends Record<string, any> ? SelectResultFields<T, true> : never;
+type SelectResultFields<TSelectedFields, TDeep extends boolean = true> = Simplify<{
+    [Key in keyof TSelectedFields]: SelectResultField<TSelectedFields[Key], TDeep>;
+}>;
+
+/**
+ * This class is used to indicate a primitive param value that is used in `sql` tag.
+ * It is only used on type level and is never instantiated at runtime.
+ * If you see a value of this type in the code, its runtime value is actually the primitive param value.
+ */
+declare class FakePrimitiveParam {
+    static readonly [entityKind]: string;
+}
+interface BuildQueryConfig {
+    casing: CasingCache;
+    escapeName(name: string): string;
+    escapeParam(num: number, value: unknown): string;
+    escapeString(str: string): string;
+    prepareTyping?: (encoder: DriverValueEncoder<unknown, unknown>) => QueryTypingsValue;
+    paramStartIndex?: {
+        value: number;
+    };
+    inlineParams?: boolean;
+    invokeSource?: 'indexes' | undefined;
+}
+type QueryTypingsValue = 'json' | 'decimal' | 'time' | 'timestamp' | 'uuid' | 'date' | 'none';
+interface Query {
+    sql: string;
+    params: unknown[];
+}
+interface QueryWithTypings extends Query {
+    typings?: QueryTypingsValue[];
+}
+/**
+ * Any value that implements the `getSQL` method. The implementations include:
+ * - `Table`
+ * - `Column`
+ * - `View`
+ * - `Subquery`
+ * - `SQL`
+ * - `SQL.Aliased`
+ * - `Placeholder`
+ * - `Param`
+ */
+interface SQLWrapper {
+    getSQL(): SQL;
+    shouldOmitSQLParens?(): boolean;
+}
+declare class StringChunk implements SQLWrapper {
+    static readonly [entityKind]: string;
+    readonly value: string[];
+    constructor(value: string | string[]);
+    getSQL(): SQL<unknown>;
+}
+type GetDecoderResult<T> = T extends Column ? T['_']['data'] : T extends DriverValueDecoder<infer TData, any> | DriverValueDecoder<infer TData, any>['mapFromDriverValue'] ? TData : never;
+/**
+ * Any DB name (table, column, index etc.)
+ */
+declare class Name implements SQLWrapper {
+    readonly value: string;
+    static readonly [entityKind]: string;
+    protected brand: 'Name';
+    constructor(value: string);
+    getSQL(): SQL<unknown>;
+}
+interface DriverValueDecoder<TData, TDriverParam> {
+    mapFromDriverValue(value: TDriverParam): TData;
+}
+interface DriverValueEncoder<TData, TDriverParam> {
+    mapToDriverValue(value: TData): TDriverParam | SQL;
+}
+interface DriverValueMapper<TData, TDriverParam> extends DriverValueDecoder<TData, TDriverParam>, DriverValueEncoder<TData, TDriverParam> {
+}
+/** Parameter value that is optionally bound to an encoder (for example, a column). */
+declare class Param<TDataType = unknown, TDriverParamType = TDataType> implements SQLWrapper {
+    readonly value: TDataType;
+    readonly encoder: DriverValueEncoder<TDataType, TDriverParamType>;
+    static readonly [entityKind]: string;
+    protected brand: 'BoundParamValue';
+    /**
+     * @param value - Parameter value
+     * @param encoder - Encoder to convert the value to a driver parameter
+     */
+    constructor(value: TDataType, encoder?: DriverValueEncoder<TDataType, TDriverParamType>);
+    getSQL(): SQL<unknown>;
+}
+/**
+ * Anything that can be passed to the `` sql`...` `` tagged function.
+ */
+type SQLChunk = StringChunk | SQLChunk[] | SQLWrapper | SQL | Table | View | Subquery | AnyColumn | Param | Name | undefined | FakePrimitiveParam | Placeholder;
+declare class SQL<T = unknown> implements SQLWrapper {
+    readonly queryChunks: SQLChunk[];
+    static readonly [entityKind]: string;
+    _: {
+        brand: 'SQL';
+        type: T;
+    };
+    private shouldInlineParams;
+    constructor(queryChunks: SQLChunk[]);
+    append(query: SQL): this;
+    toQuery(config: BuildQueryConfig): QueryWithTypings;
+    buildQueryFromSourceParams(chunks: SQLChunk[], _config: BuildQueryConfig): Query;
+    private mapInlineParam;
+    getSQL(): SQL;
+    as(alias: string): SQL.Aliased<T>;
+    /**
+     * @deprecated
+     * Use ``sql<DataType>`query`.as(alias)`` instead.
+     */
+    as<TData>(): SQL<TData>;
+    /**
+     * @deprecated
+     * Use ``sql<DataType>`query`.as(alias)`` instead.
+     */
+    as<TData>(alias: string): SQL.Aliased<TData>;
+    mapWith<TDecoder extends DriverValueDecoder<any, any> | DriverValueDecoder<any, any>['mapFromDriverValue']>(decoder: TDecoder): SQL<GetDecoderResult<TDecoder>>;
+    inlineParams(): this;
+    /**
+     * This method is used to conditionally include a part of the query.
+     *
+     * @param condition - Condition to check
+     * @returns itself if the condition is `true`, otherwise `undefined`
+     */
+    if(condition: any | undefined): this | undefined;
+}
+declare namespace SQL {
+    class Aliased<T = unknown> implements SQLWrapper {
+        readonly sql: SQL;
+        readonly fieldAlias: string;
+        static readonly [entityKind]: string;
+        _: {
+            brand: 'SQL.Aliased';
+            type: T;
+        };
+        constructor(sql: SQL, fieldAlias: string);
+        getSQL(): SQL;
+    }
+}
+declare class Placeholder<TName extends string = string, TValue = any> implements SQLWrapper {
+    readonly name: TName;
+    static readonly [entityKind]: string;
+    protected: TValue;
+    constructor(name: TName);
+    getSQL(): SQL;
+}
+type ColumnsSelection = Record<string, unknown>;
+declare abstract class View<TName extends string = string, TExisting extends boolean = boolean, TSelection extends ColumnsSelection = ColumnsSelection> implements SQLWrapper {
+    static readonly [entityKind]: string;
+    _: {
+        brand: 'View';
+        viewBrand: string;
+        name: TName;
+        existing: TExisting;
+        selectedFields: TSelection;
+    };
+    readonly $inferSelect: InferSelectViewModel<View<Assume<TName, string>, TExisting, TSelection>>;
+    constructor({ name, schema, selectedFields, query }: {
+        name: TName;
+        schema: string | undefined;
+        selectedFields: ColumnsSelection;
+        query: SQL | undefined;
     });
-    protected request<T>(method: string, url: string, body?: Record<string, any> | FormData, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    getSQL(): SQL<unknown>;
 }
+type InferSelectViewModel<TView extends View> = Equal<TView['_']['selectedFields'], {
+    [x: string]: unknown;
+}> extends true ? {
+    [x: string]: unknown;
+} : SelectResult<TView['_']['selectedFields'], 'single', Record<TView['_']['name'], 'not-null'>>;
+
+type RequiredKeyOnly<TKey extends string, T extends Column> = T extends AnyColumn<{
+    notNull: true;
+    hasDefault: false;
+}> ? TKey : never;
+type OptionalKeyOnly<TKey extends string, T extends Column, OverrideT extends boolean | undefined = false> = TKey extends RequiredKeyOnly<TKey, T> ? never : T extends {
+    _: {
+        generated: undefined;
+    };
+} ? (T extends {
+    _: {
+        identity: undefined;
+    };
+} ? TKey : T['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never : TKey) : never;
+
+type Update<T, TUpdate> = {
+    [K in Exclude<keyof T, keyof TUpdate>]: T[K];
+} & TUpdate;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Not<T extends boolean> = T extends true ? false : true;
+type IsNever<T> = [T] extends [never] ? true : false;
+type IsUnion<T, U extends T = T> = (T extends any ? (U extends T ? false : true) : never) extends false ? false : true;
+type FromSingleKeyObject<T, Result, TError extends string, K = keyof T> = IsNever<K> extends true ? never : IsUnion<K> extends true ? DrizzleTypeError<TError> : Result;
+type Assume<T, U> = T extends U ? T : U;
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+interface DrizzleTypeError<T extends string> {
+    $drizzleTypeError: T;
+}
+type Casing = 'snake_case' | 'camelCase';
+
+type PgSequenceOptions = {
+    increment?: number | string;
+    minValue?: number | string;
+    maxValue?: number | string;
+    startWith?: number | string;
+    cache?: number | string;
+    cycle?: boolean;
+};
+
+type TableConfig = TableConfig$1<SQLiteColumn<any>>;
+declare class SQLiteTable<T extends TableConfig = TableConfig> extends Table<T> {
+    static readonly [entityKind]: string;
+}
+type SQLiteTableWithColumns<T extends TableConfig> = SQLiteTable<T> & {
+    [Key in keyof T['columns']]: T['columns'][Key];
+};
+
+declare abstract class SQLiteColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends Column<T, TRuntimeConfig, TTypeConfig & {
+    dialect: 'sqlite';
+}> {
+    readonly table: SQLiteTable;
+    static readonly [entityKind]: string;
+    constructor(table: SQLiteTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+}
+
+type ColumnDataType = 'string' | 'number' | 'boolean' | 'array' | 'json' | 'date' | 'bigint' | 'custom' | 'buffer' | 'dateDuration' | 'duration' | 'relDuration' | 'localTime' | 'localDate' | 'localDateTime';
+type GeneratedStorageMode = 'virtual' | 'stored';
+type GeneratedType = 'always' | 'byDefault';
+type GeneratedColumnConfig<TDataType> = {
+    as: TDataType | SQL | (() => SQL);
+    type?: GeneratedType;
+    mode?: GeneratedStorageMode;
+};
+type GeneratedIdentityConfig = {
+    sequenceName?: string;
+    sequenceOptions?: PgSequenceOptions;
+    type: 'always' | 'byDefault';
+};
+interface ColumnBuilderBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> {
+    name: string;
+    dataType: TDataType;
+    columnType: TColumnType;
+    data: unknown;
+    driverParam: unknown;
+    enumValues: string[] | undefined;
+}
+type ColumnBuilderRuntimeConfig<TData, TRuntimeConfig extends object = object> = {
+    name: string;
+    keyAsName: boolean;
+    notNull: boolean;
+    default: TData | SQL | undefined;
+    defaultFn: (() => TData | SQL) | undefined;
+    onUpdateFn: (() => TData | SQL) | undefined;
+    hasDefault: boolean;
+    primaryKey: boolean;
+    isUnique: boolean;
+    uniqueName: string | undefined;
+    uniqueType: string | undefined;
+    dataType: string;
+    columnType: string;
+    generated: GeneratedColumnConfig<TData> | undefined;
+    generatedIdentity: GeneratedIdentityConfig | undefined;
+} & TRuntimeConfig;
+
+interface ColumnBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> extends ColumnBuilderBaseConfig<TDataType, TColumnType> {
+    tableName: string;
+    notNull: boolean;
+    hasDefault: boolean;
+    isPrimaryKey: boolean;
+    isAutoincrement: boolean;
+    hasRuntimeDefault: boolean;
+}
+type ColumnTypeConfig<T extends ColumnBaseConfig<ColumnDataType, string>, TTypeConfig extends object> = T & {
+    brand: 'Column';
+    tableName: T['tableName'];
+    name: T['name'];
+    dataType: T['dataType'];
+    columnType: T['columnType'];
+    data: T['data'];
+    driverParam: T['driverParam'];
+    notNull: T['notNull'];
+    hasDefault: T['hasDefault'];
+    isPrimaryKey: T['isPrimaryKey'];
+    isAutoincrement: T['isAutoincrement'];
+    hasRuntimeDefault: T['hasRuntimeDefault'];
+    enumValues: T['enumValues'];
+    baseColumn: T extends {
+        baseColumn: infer U;
+    } ? U : unknown;
+    generated: GeneratedColumnConfig<T['data']> | undefined;
+    identity: undefined | 'always' | 'byDefault';
+} & TTypeConfig;
+type ColumnRuntimeConfig<TData, TRuntimeConfig extends object> = ColumnBuilderRuntimeConfig<TData, TRuntimeConfig>;
+interface Column<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object> extends DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
+}
+declare abstract class Column<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object> implements DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
+    readonly table: Table;
+    static readonly [entityKind]: string;
+    readonly _: ColumnTypeConfig<T, TTypeConfig>;
+    readonly name: string;
+    readonly keyAsName: boolean;
+    readonly primary: boolean;
+    readonly notNull: boolean;
+    readonly default: T['data'] | SQL | undefined;
+    readonly defaultFn: (() => T['data'] | SQL) | undefined;
+    readonly onUpdateFn: (() => T['data'] | SQL) | undefined;
+    readonly hasDefault: boolean;
+    readonly isUnique: boolean;
+    readonly uniqueName: string | undefined;
+    readonly uniqueType: string | undefined;
+    readonly dataType: T['dataType'];
+    readonly columnType: T['columnType'];
+    readonly enumValues: T['enumValues'];
+    readonly generated: GeneratedColumnConfig<T['data']> | undefined;
+    readonly generatedIdentity: GeneratedIdentityConfig | undefined;
+    protected config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>;
+    constructor(table: Table, config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>);
+    abstract getSQLType(): string;
+    mapFromDriverValue(value: unknown): unknown;
+    mapToDriverValue(value: unknown): unknown;
+}
+type AnyColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = Column<Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>>;
+type GetColumnData<TColumn extends Column, TInferMode extends 'query' | 'raw' = 'query'> = TInferMode extends 'raw' ? TColumn['_']['data'] : TColumn['_']['notNull'] extends true ? TColumn['_']['data'] : TColumn['_']['data'] | null;
+
+declare const files: SQLiteTableWithColumns<{
+    name: "files";
+    schema: undefined;
+    columns: {
+        createdAt: SQLiteColumn<{
+            name: "created_at";
+            tableName: "files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        updatedAt: SQLiteColumn<{
+            name: "updated_at";
+            tableName: "files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        id: SQLiteColumn<{
+            name: "id";
+            tableName: "files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        name: SQLiteColumn<{
+            name: "name";
+            tableName: "files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        type: SQLiteColumn<{
+            name: "type";
+            tableName: "files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        path: SQLiteColumn<{
+            name: "path";
+            tableName: "files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        folderId: SQLiteColumn<{
+            name: "folder_id";
+            tableName: "files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        size: SQLiteColumn<{
+            name: "size";
+            tableName: "files";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+type File$1 = InferSelectModel<typeof files>;
+
+declare const folders: SQLiteTableWithColumns<{
+    name: "folders";
+    schema: undefined;
+    columns: {
+        createdAt: SQLiteColumn<{
+            name: "created_at";
+            tableName: "folders";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        updatedAt: SQLiteColumn<{
+            name: "updated_at";
+            tableName: "folders";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        id: SQLiteColumn<{
+            name: "id";
+            tableName: "folders";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        name: SQLiteColumn<{
+            name: "name";
+            tableName: "folders";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        path: SQLiteColumn<{
+            name: "path";
+            tableName: "folders";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        parentId: SQLiteColumn<{
+            name: "parent_id";
+            tableName: "folders";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+type Folder = InferSelectModel<typeof folders>;
+
+type ApiResponse<T> = {
+    data: T;
+    error: null;
+} | {
+    data: null;
+    error: {
+        message: string;
+    };
+};
+type FileWithUrl = File$1 & {
+    url: string;
+};
 
 declare class Files extends Base {
-    getAll(options?: {
-        limit?: number;
-        offset?: number;
-        orderBy?: "created_at" | "updated_at" | "name" | "size";
-        orderDirection?: "ASC" | "DESC";
-    }): Promise<{
+    getAll(options?: ListOptions): Promise<{
         error: {
             message: string;
         } | null;
         data: {
-            files: {
-                url: string;
-                id: string;
-                name: string;
-                folder_id: string;
-                path: string;
-                size: number;
-                type: string;
-                created_at: string;
-                updated_at: string;
-            }[];
+            files: any[];
         } | null;
     }>;
     getById(id: string): Promise<{
@@ -41,119 +723,98 @@ declare class Files extends Base {
             message: string;
         } | null;
         data: {
-            file: {
-                url: string;
-                id: string;
-                name: string;
-                folder_id: string;
-                path: string;
-                size: number;
-                type: string;
-                created_at: string;
-                updated_at: string;
-            } | undefined;
+            file: any;
         } | null;
     }>;
-    getByName(name: string, options?: {
-        limit?: number;
-        offset?: number;
-        orderBy?: "created_at" | "updated_at" | "name" | "size";
-        orderDirection?: "ASC" | "DESC";
-    }): Promise<{
+    getByName(name: string, options?: ListOptions): Promise<{
         error: {
             message: string;
         } | null;
         data: {
-            files: {
-                url: string;
-                id: string;
-                name: string;
-                folder_id: string;
-                path: string;
-                size: number;
-                type: string;
-                created_at: string;
-                updated_at: string;
-            }[];
+            files: any[];
         } | null;
     }>;
     upload(data: {
-        files: FileWithUrl[];
+        files: File[];
         folder?: string;
     }): Promise<{
         error: {
             message: string;
         } | null;
         data: {
-            files: {
-                url: string;
-                id: string;
-                name: string;
-                folder_id: string;
-                path: string;
-                size: number;
-                type: string;
-                created_at: string;
-                updated_at: string;
-            }[];
+            files: any[];
         } | null;
     }>;
+    download(id: string): Promise<ApiResponse<{
+        blob: Blob;
+        filename: string | null;
+        contentType: string;
+    }>>;
     rename(data: {
         id: string;
         name: string;
-    }): Promise<_repo_types.ApiResponse<null>>;
-    delete(id: string): Promise<_repo_types.ApiResponse<null>>;
+    }): Promise<ApiResponse<null>>;
+    delete(id: string): Promise<ApiResponse<null>>;
 }
 
 declare class Folders extends Base {
-    get(options?: {
+    get(options?: ListOptions & {
         id?: string;
         path?: string;
-        limit?: number;
-        offset?: number;
-        orderBy?: "created_at" | "updated_at" | "name";
-        orderDirection?: "ASC" | "DESC";
     }): Promise<{
         error: {
             message: string;
         } | null;
         data: {
-            files: {
-                url: string;
-                id: string;
-                name: string;
-                folder_id: string;
-                path: string;
-                size: number;
-                type: string;
-                created_at: string;
-                updated_at: string;
-            }[];
+            files: any[];
             folders: Folder[];
         } | null;
     }>;
-    create(folder: string): Promise<_repo_types.ApiResponse<{
+    create(folder: string): Promise<ApiResponse<{
         folder: Folder;
     }>>;
     rename(data: {
         id: string;
         name: string;
-    }): Promise<_repo_types.ApiResponse<null>>;
-    delete(id: string): Promise<_repo_types.ApiResponse<null>>;
+    }): Promise<ApiResponse<null>>;
+    delete(id: string): Promise<ApiResponse<null>>;
 }
 
 interface IVaze {
     files: Files;
     folders: Folders;
 }
+type VazeOptions = {
+    apiKey?: string;
+    vazeUrl?: string;
+};
+type ListOptions = {
+    limit?: number;
+    offset?: number;
+    orderBy?: "createdAt" | "updatedAt" | "name" | "size";
+    orderDirection?: "ASC" | "DESC";
+};
+
+declare class Base {
+    private apiKey;
+    protected vazeUrl: string;
+    constructor(options?: VazeOptions);
+    protected apiUrl(path: string, params?: Record<string, string | number | undefined>): string;
+    protected request<T>(method: string, url: string, body?: Record<string, any> | FormData, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    protected requestBlob(url: string): Promise<ApiResponse<{
+        blob: Blob;
+        filename: string | null;
+        contentType: string;
+    }>>;
+}
 
 declare class Vaze extends Base implements IVaze {
     files: Files;
     folders: Folders;
-    constructor(options?: {
-        apiKey?: string;
-        vazeUrl?: string;
-    });
+    constructor(options?: VazeOptions);
+    health(): Promise<ApiResponse<{
+        message: string;
+    }>>;
 }
 
-export { Vaze as default };
+export { type ApiResponse, type FileWithUrl as File, type Folder, type ListOptions, type VazeOptions, Vaze as default };