@myco-dev/sdk 0.1.10 → 0.1.12

package/dist/use-subscription-BUFAoTSc.d.ts

@@ -0,0 +1,1002 @@
+import { a as MycoSDKConfig, d as UseSessionResult, m as WorkspaceMember, o as MycoSession, p as Workspace } from "./types-CV6TFukn.js";
+import * as ai from "ai";
+import { DefaultChatTransport, UIMessage } from "ai";
+
+//#region ../../node_modules/drizzle-orm/entity.d.ts
+declare const entityKind: unique symbol;
+//#endregion
+//#region ../../node_modules/drizzle-orm/casing.d.ts
+declare class CasingCache {
+  static readonly [entityKind]: string;
+  private cachedTables;
+  private convert;
+  constructor(casing?: Casing);
+  getColumnCasing(column: Column): string;
+  private cacheTable;
+  clearCache(): void;
+}
+//#endregion
+//#region ../../node_modules/drizzle-orm/subquery.d.ts
+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;
+  };
+  constructor(sql: SQL, selection: Record<string, unknown>, alias: string, isWith?: boolean);
+}
+//#endregion
+//#region ../../node_modules/drizzle-orm/table.d.ts
+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>;
+//#endregion
+//#region ../../node_modules/drizzle-orm/query-builders/select.types.d.ts
+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 IsUnion<T, U extends T = T> = (T extends any ? (U extends T ? false : true) : never) extends false ? false : true;
+type Not<T extends boolean> = T extends true ? false : true;
+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 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> }>;
+//#endregion
+//#region ../../node_modules/drizzle-orm/sql/sql.d.ts
+/**
+ * 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>;
+}
+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;
+}
+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>;
+}
+/**
+ * Any DB name (table, column, index etc.)
+ * @deprecated Use `sql.identifier` instead.
+ */
+declare function name(value: string): Name;
+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 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;
+  });
+  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'>>;
+//#endregion
+//#region ../../node_modules/drizzle-orm/utils.d.ts
+type Update<T, TUpdate> = { [K in Exclude<keyof T, keyof TUpdate>]: T[K] } & TUpdate;
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+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';
+//#endregion
+//#region ../../node_modules/drizzle-orm/column-builder.d.ts
+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;
+//#endregion
+//#region ../../node_modules/drizzle-orm/column.d.ts
+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;
+//#endregion
+//#region ../../node_modules/drizzle-orm/operations.d.ts
+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['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never : TKey) : never;
+//#endregion
+//#region ../../node_modules/drizzle-orm/pg-core/sequence.d.ts
+type PgSequenceOptions = {
+  increment?: number | string;
+  minValue?: number | string;
+  maxValue?: number | string;
+  startWith?: number | string;
+  cache?: number | string;
+  cycle?: boolean;
+};
+//#endregion
+//#region ../../node_modules/drizzle-orm/pg-core/table.d.ts
+type TableConfig = TableConfig$1<PgColumn>;
+declare class PgTable<T extends TableConfig = TableConfig> extends Table<T> {
+  static readonly [entityKind]: string;
+}
+type PgTableWithColumns<T extends TableConfig> = PgTable<T> & { [Key in keyof T['columns']]: T['columns'][Key] } & {
+  enableRLS: () => Omit<PgTableWithColumns<T>, 'enableRLS'>;
+};
+//#endregion
+//#region ../../node_modules/drizzle-orm/pg-core/columns/common.d.ts
+declare abstract class PgColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends Column<T, TRuntimeConfig, TTypeConfig & {
+  dialect: 'pg';
+}> {
+  readonly table: PgTable;
+  static readonly [entityKind]: string;
+  constructor(table: PgTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+}
+//#endregion
+//#region ../db/src/schema.d.ts
+declare const chats: PgTableWithColumns<{
+  name: "chats";
+  schema: "myco";
+  columns: {
+    id: PgColumn<{
+      name: "id";
+      tableName: "chats";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    title: PgColumn<{
+      name: "title";
+      tableName: "chats";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    userId: PgColumn<{
+      name: "user_id";
+      tableName: "chats";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    workspaceId: PgColumn<{
+      name: "workspace_id";
+      tableName: "chats";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    appSlug: PgColumn<{
+      name: "app_slug";
+      tableName: "chats";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    visibility: PgColumn<{
+      name: "visibility";
+      tableName: "chats";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    model: PgColumn<{
+      name: "model";
+      tableName: "chats";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    loadedSkills: PgColumn<{
+      name: "loaded_skills";
+      tableName: "chats";
+      dataType: "json";
+      columnType: "PgJsonb";
+      data: string[];
+      driverParam: unknown;
+      notNull: false;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      $type: string[];
+    }>;
+    isPinned: PgColumn<{
+      name: "is_pinned";
+      tableName: "chats";
+      dataType: "boolean";
+      columnType: "PgBoolean";
+      data: boolean;
+      driverParam: boolean;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    chatType: PgColumn<{
+      name: "chat_type";
+      tableName: "chats";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    createdAt: PgColumn<{
+      name: "created_at";
+      tableName: "chats";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    updatedAt: PgColumn<{
+      name: "updated_at";
+      tableName: "chats";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}>;
+type MessagePart = {
+  type: "text";
+  text: string;
+} | {
+  type: "file";
+  url: string;
+  mediaType?: string;
+  filename?: string;
+} | {
+  type: "reasoning";
+  text: string;
+} | {
+  type: `tool-${string}`;
+  toolCallId: string;
+  state: "call" | "result";
+  input?: unknown;
+  output?: unknown;
+};
+declare const messages: PgTableWithColumns<{
+  name: "messages";
+  schema: "myco";
+  columns: {
+    id: PgColumn<{
+      name: "id";
+      tableName: "messages";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    chatId: PgColumn<{
+      name: "chat_id";
+      tableName: "messages";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    role: PgColumn<{
+      name: "role";
+      tableName: "messages";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    content: PgColumn<{
+      name: "content";
+      tableName: "messages";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    parts: PgColumn<{
+      name: "parts";
+      tableName: "messages";
+      dataType: "json";
+      columnType: "PgJsonb";
+      data: MessagePart[];
+      driverParam: unknown;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      $type: MessagePart[];
+    }>;
+    attachments: PgColumn<{
+      name: "attachments";
+      tableName: "messages";
+      dataType: "json";
+      columnType: "PgJsonb";
+      data: {
+        type: string;
+        mediaType?: string;
+        url?: string;
+        filename?: string;
+      }[];
+      driverParam: unknown;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      $type: {
+        type: string;
+        mediaType?: string;
+        url?: string;
+        filename?: string;
+      }[];
+    }>;
+    metadata: PgColumn<{
+      name: "metadata";
+      tableName: "messages";
+      dataType: "json";
+      columnType: "PgJsonb";
+      data: Record<string, unknown>;
+      driverParam: unknown;
+      notNull: false;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      $type: Record<string, unknown>;
+    }>;
+    createdAt: PgColumn<{
+      name: "created_at";
+      tableName: "messages";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    completedAt: PgColumn<{
+      name: "completed_at";
+      tableName: "messages";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}>;
+//#endregion
+//#region ../types/src/chat.d.ts
+/**
+ * Utility: Convert Date fields to string (JSON serialization).
+ * When Hono returns c.json(drizzleRow), Date becomes an ISO string.
+ */
+type Serialized<T> = { [K in keyof T]: T[K] extends Date ? string : T[K] extends Date | null ? string | null : T[K] };
+/**
+ * Chat record as returned by the API.
+ * Derived from the Drizzle schema with Date → string serialization applied.
+ */
+type Chat = Serialized<typeof chats.$inferSelect>;
+/**
+ * Chat message record as returned by the API.
+ * Derived from the Drizzle schema with Date → string serialization applied.
+ */
+type ChatMessage = Serialized<typeof messages.$inferSelect>;
+//#endregion
+//#region src/auth/manager.d.ts
+/**
+ * Auth namespace — federated login, logout, session management.
+ */
+declare class AuthManager {
+  private authClient;
+  constructor(config: MycoSDKConfig);
+  login(returnTo?: string): void;
+  logout(): Promise<void>;
+  useSession(): UseSessionResult;
+  getSession(): Promise<MycoSession | null>;
+}
+//#endregion
+//#region src/workspace/manager.d.ts
+type ApiRequest$1 = <T>(path: string, options?: RequestInit) => Promise<T>;
+interface UseWorkspaceResult {
+  data: Workspace | null;
+  isPending: boolean;
+  error: Error | null;
+}
+/**
+ * Manages workspace members for the current workspace.
+ */
+declare class WorkspaceMembersManager {
+  private requireWorkspaceId;
+  private apiRequest;
+  constructor(requireWorkspaceId: () => string, apiRequest: ApiRequest$1);
+  get(): Promise<WorkspaceMember[]>;
+  add(userId: string, role?: "admin" | "member"): Promise<WorkspaceMember>;
+  remove(userId: string): Promise<void>;
+}
+/**
+ * Manages workspaces — owns initialization logic, provides CRUD + React hook.
+ */
+declare class WorkspaceManager {
+  private appKey;
+  private getConfig;
+  private setWorkspaceId;
+  private apiRequest;
+  private auth;
+  private redirectOnUnauth;
+  readonly ready: Promise<void>;
+  readonly members: WorkspaceMembersManager;
+  private readyResolve;
+  private readyReject;
+  constructor(appKey: string, getConfig: () => MycoSDKConfig, setWorkspaceId: (id: string) => void, apiRequest: ApiRequest$1, auth: {
+    login: () => void;
+  }, redirectOnUnauth: boolean);
+  private requireWorkspaceId;
+  private init;
+  private joinApp;
+  private ensure;
+  list(): Promise<Workspace[]>;
+  current(): Promise<Workspace>;
+  switch(workspaceId: string): void;
+  update(data: {
+    name?: string;
+  }): Promise<Workspace>;
+  useWorkspace(): UseWorkspaceResult;
+}
+//#endregion
+//#region src/chat/namespace.d.ts
+type ApiRequest = <T>(path: string, options?: RequestInit) => Promise<T>;
+/**
+ * Chat namespace — chat CRUD, transport factory, React Query hooks.
+ */
+declare class ChatManager {
+  private apiRequest;
+  private getConfig;
+  constructor(apiRequest: ApiRequest, getConfig: () => MycoSDKConfig);
+  getChats(): Promise<Chat[]>;
+  getChat(chatId: string): Promise<Chat | null>;
+  getChatMessages(chatId: string): Promise<ChatMessage[]>;
+  updateChat(chatId: string, data: {
+    title?: string;
+    isPinned?: boolean;
+  }): Promise<Chat>;
+  deleteChat(chatId: string): Promise<void>;
+  createTransport(): DefaultChatTransport<UIMessage<unknown, ai.UIDataTypes, ai.UITools>>;
+  useChats(): {
+    chats: {
+      title: string | null;
+      id: string;
+      createdAt: string;
+      updatedAt: string;
+      userId: string;
+      workspaceId: string | null;
+      appSlug: string | null;
+      visibility: string;
+      model: string | null;
+      loadedSkills: string[] | null;
+      isPinned: boolean;
+      chatType: string;
+    }[];
+    isLoading: boolean;
+    error: Error | null;
+    mutate: (data: Chat[] | ((current: Chat[] | undefined) => Chat[] | undefined), options?: {
+      revalidate?: boolean;
+    }) => void;
+  };
+  useChat(chatId: string | null | undefined): {
+    chat: {
+      title: string | null;
+      id: string;
+      createdAt: string;
+      updatedAt: string;
+      userId: string;
+      workspaceId: string | null;
+      appSlug: string | null;
+      visibility: string;
+      model: string | null;
+      loadedSkills: string[] | null;
+      isPinned: boolean;
+      chatType: string;
+    } | null;
+    isLoading: boolean;
+    error: Error | null;
+    mutate: (data: Chat | null | ((current: Chat | null | undefined) => Chat | null | undefined), options?: {
+      revalidate?: boolean;
+    }) => void;
+  };
+  private static emptyUIMessages;
+  useChatMessages(chatId: string | null | undefined): {
+    messages: UIMessage<unknown, ai.UIDataTypes, ai.UITools>[];
+    isLoading: boolean;
+    error: Error | null;
+    mutate: (data: ChatMessage[] | null | ((current: ChatMessage[] | null | undefined) => ChatMessage[] | null | undefined), options?: {
+      revalidate?: boolean;
+    }) => void;
+    onChange: (newMessages: UIMessage[]) => void;
+  };
+}
+//#endregion
+//#region src/files.d.ts
+type AuthenticatedFetch = (path: string, options?: RequestInit) => Promise<Response>;
+/**
+ * Files namespace — file uploads.
+ */
+declare class FilesManager {
+  private authenticatedFetch;
+  constructor(authenticatedFetch: AuthenticatedFetch);
+  upload(file: File): Promise<string>;
+}
+//#endregion
+//#region src/use-subscription.d.ts
+/**
+ * useSubscription — stub hook for subscription/usage data.
+ * Vibekit apps are currently unlimited.
+ */
+declare function useSubscription(): {
+  usage: {
+    unlimited: boolean;
+    remaining: number;
+    limit: number;
+    used: number;
+  };
+  isLoading: boolean;
+  error: null;
+};
+//#endregion
+export { AuthManager as a, WorkspaceManager as i, FilesManager as n, Chat as o, ChatManager as r, ChatMessage as s, useSubscription as t };
+//# sourceMappingURL=use-subscription-BUFAoTSc.d.ts.map