nautilus-orm-codegen 1.0.1

// Generated by nautilus-codegen. Do not edit manually.

import type { NautilusClient } from '../_internal/_client.js';
{%- if has_enums %}
import type { {% for e in enum_imports %}{{ e }}{% if not loop.last %}, {% endif %}{% endfor %} } from '../enums.js';
{%- endif %}
{%- if has_composite_types %}
import type { {% for t in composite_type_imports %}{{ t }}{% if not loop.last %}, {% endif %}{% endfor %} } from '../types.js';
{%- endif %}

export interface StringFilter {
  contains?:   string;
  startsWith?: string;
  endsWith?:   string;
  in?:         string[];
  notIn?:      string[];
  not?:        string;
  isNull?:     boolean;
}

export interface NumberFilter {
  lt?:     number;
  lte?:    number;
  gt?:     number;
  gte?:    number;
  in?:     number[];
  notIn?:  number[];
  not?:    number;
  isNull?: boolean;
}

export interface DateFilter {
  lt?:     Date;
  lte?:    Date;
  gt?:     Date;
  gte?:    Date;
  in?:     Date[];
  notIn?:  Date[];
  not?:    Date;
  isNull?: boolean;
}

export type SortOrder = 'asc' | 'desc';

export interface {{ model_name }}Model {
{%- for f in scalar_fields %}
  {{ f.name }}{% if not f.is_pk %}?{% endif %}: {{ f.ts_type }};
{%- endfor %}
{%- for f in relation_fields %}
  {{ f.name }}?: {{ f.ts_type }};
{%- endfor %}
}

export interface {{ model_name }}WhereInput {
{%- for field in where_input_fields %}
{%- if field.base_type == "string" %}
  {{ field.name }}?: string | StringFilter;
{%- elif field.base_type == "number" %}
  {{ field.name }}?: number | NumberFilter;
{%- elif field.base_type == "Date" %}
  {{ field.name }}?: Date | DateFilter;
{%- elif field.base_type == "boolean" %}
  {{ field.name }}?: boolean;
{%- else %}
  {{ field.name }}?: {{ field.ts_type }};
{%- endif %}
{%- endfor %}
  AND?: {{ model_name }}WhereInput | {{ model_name }}WhereInput[];
  OR?:  {{ model_name }}WhereInput[];
  NOT?: {{ model_name }}WhereInput | {{ model_name }}WhereInput[];
}

export interface {{ model_name }}CreateInput {
{%- for field in create_input_fields %}
{%- if field.is_required %}
  {{ field.name }}: {{ field.ts_type }};
{%- else %}
  {{ field.name }}?: {{ field.ts_type }};
{%- endif %}
{%- endfor %}
}

export interface {{ model_name }}UpdateInput {
{%- for field in update_input_fields %}
  {{ field.name }}?: {{ field.ts_type }};
{%- endfor %}
}

export interface {{ model_name }}OrderByInput {
{%- for field in order_by_fields %}
  {{ field.name }}?: SortOrder;
{%- endfor %}
}

export interface {{ model_name }}SelectInput {
{%- for field in scalar_fields %}
  {{ field.name }}?: boolean;
{%- endfor %}
}

{%- if has_includes %}

export interface {{ model_name }}IncludeInput {
{%- for field in include_fields %}
  {{ field.name }}?: boolean | FindMany{{ field.target_model }}ArgsFrom{{ model_name }};
{%- endfor %}
}

{%- for field in include_fields %}
export interface FindMany{{ field.target_model }}ArgsFrom{{ model_name }} {
  where?:    {{ field.target_model }}WhereInput;
  orderBy?:  {{ field.target_model }}OrderByInput;
{%- if field.is_array %}
  take?:     number;
  skip?:     number;
  cursor?:   Record<string, unknown>;
  distinct?: string[];
{%- endif %}
  include?:  {{ field.target_model }}IncludeInput;
}
{%- endfor %}

{%- endif %}

export interface {{ model_name }}UpsertInput {
  create: {{ model_name }}CreateInput;
  update: {{ model_name }}UpdateInput;
}

export type {{ model_name }}ScalarFieldKeys = {% for f in scalar_fields %}'{{ f.name }}'{% if not loop.last %} | {% endif %}{% endfor %};

export interface {{ model_name }}CountAggregateInput {
  _all?: boolean;
{%- for f in scalar_fields %}
  {{ f.name }}?: boolean;
{%- endfor %}
}

{%- if has_numeric_fields %}
export interface {{ model_name }}AvgAggregateInput {
{%- for f in numeric_fields %}
  {{ f.name }}?: boolean;
{%- endfor %}
}
export interface {{ model_name }}SumAggregateInput {
{%- for f in numeric_fields %}
  {{ f.name }}?: boolean;
{%- endfor %}
}
{%- endif %}

export interface {{ model_name }}MinAggregateInput {
{%- for f in orderable_fields %}
  {{ f.name }}?: boolean;
{%- endfor %}
}

export interface {{ model_name }}MaxAggregateInput {
{%- for f in orderable_fields %}
  {{ f.name }}?: boolean;
{%- endfor %}
}

export interface {{ model_name }}GroupByOutput {
{%- for f in scalar_fields %}
  {{ f.name }}?: {{ f.ts_type }};
{%- endfor %}
  _count?: Record<string, number>;
  _avg?:   Record<string, number>;
  _sum?:   Record<string, unknown>;
  _min?:   Record<string, unknown>;
  _max?:   Record<string, unknown>;
}

export declare class {{ delegate_name }} {
  client: NautilusClient;
  constructor(client: NautilusClient);

  findMany(args?: {
    where?:    {{ model_name }}WhereInput;
    orderBy?:  {{ model_name }}OrderByInput | {{ model_name }}OrderByInput[];
    take?:     number;
    skip?:     number;
    select?:   {{ model_name }}SelectInput;
    include?:  {% if has_includes %}{{ model_name }}IncludeInput{% else %}Record<string, unknown>{% endif %};
    cursor?:   Record<string, unknown>;
    distinct?: string[];
    chunkSize?: number;
  }): Promise<{{ model_name }}Model[]>;

  findFirst(args?: {
    where?:   {{ model_name }}WhereInput;
    orderBy?: {{ model_name }}OrderByInput | {{ model_name }}OrderByInput[];
    select?:  {{ model_name }}SelectInput;
    include?: {% if has_includes %}{{ model_name }}IncludeInput{% else %}Record<string, unknown>{% endif %};
  }): Promise<{{ model_name }}Model | null>;

  findUnique(args: {
    where:    {{ model_name }}WhereInput;
    select?:  {{ model_name }}SelectInput;
    include?: {% if has_includes %}{{ model_name }}IncludeInput{% else %}Record<string, unknown>{% endif %};
  }): Promise<{{ model_name }}Model | null>;

  findUniqueOrThrow(args: {
    where:    {{ model_name }}WhereInput;
    select?:  {{ model_name }}SelectInput;
    include?: {% if has_includes %}{{ model_name }}IncludeInput{% else %}Record<string, unknown>{% endif %};
  }): Promise<{{ model_name }}Model>;

  findFirstOrThrow(args?: {
    where?:   {{ model_name }}WhereInput;
    orderBy?: {{ model_name }}OrderByInput | {{ model_name }}OrderByInput[];
    select?:  {{ model_name }}SelectInput;
    include?: {% if has_includes %}{{ model_name }}IncludeInput{% else %}Record<string, unknown>{% endif %};
  }): Promise<{{ model_name }}Model>;

  create(args: {
    data:        {{ model_name }}CreateInput;
    returnData?: boolean;
  }): Promise<{{ model_name }}Model | null>;

  createMany(args: {
    data:        {{ model_name }}CreateInput[];
    returnData?: boolean;
  }): Promise<{{ model_name }}Model[]>;

  update(args: {
    where?:      {{ model_name }}WhereInput;
    data:        {{ model_name }}UpdateInput;
    returnData?: boolean;
  }): Promise<{{ model_name }}Model[] | number>;

  delete(args: {
    where:       {{ model_name }}WhereInput;
    returnData?: boolean;
  }): Promise<{{ model_name }}Model | null>;

  deleteMany(args?: {
    where?:      {{ model_name }}WhereInput;
    returnData?: boolean;
  }): Promise<{{ model_name }}Model[] | number>;

  count(args?: {
    where?:  {{ model_name }}WhereInput;
    take?:   number;
    skip?:   number;
    cursor?: Record<string, unknown>;
  }): Promise<number>;

  /** Execute a raw SQL string and return result rows as generic objects. */
  rawQuery(sql: string): Promise<Record<string, unknown>[]>;

  /** Execute a raw prepared-statement query with bound parameters. */
  rawStmtQuery(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;

  upsert(args: {
    where:       {{ model_name }}WhereInput;
    data:        {{ model_name }}UpsertInput;
    include?:    {% if has_includes %}{{ model_name }}IncludeInput{% else %}Record<string, unknown>{% endif %};
    returnData?: boolean;
  }): Promise<{{ model_name }}Model | null>;

  groupBy(args: {
    by:      {{ model_name }}ScalarFieldKeys[];
    where?:  {{ model_name }}WhereInput;
    having?: Record<string, unknown>;
    take?:   number;
    skip?:   number;
    count?:  boolean | {{ model_name }}CountAggregateInput;
{%- if has_numeric_fields %}
    avg?:    {{ model_name }}AvgAggregateInput;
    sum?:    {{ model_name }}SumAggregateInput;
{%- endif %}
    min?:    {{ model_name }}MinAggregateInput;
    max?:    {{ model_name }}MaxAggregateInput;
    order?:  Record<string, SortOrder> | Record<string, SortOrder>[];
  }): Promise<{{ model_name }}GroupByOutput[]>;
}

export type { NautilusClient };