@danceroutine/tango-resources 1.11.3 → 1.11.4

package/dist/index-Bg6TtnmQ.d.ts

@@ -0,0 +1,175 @@
+import { r as RequestContext } from "./index-BJJalUDB.js";
+import { o as FilterSet } from "./index-CiIB-1Ac.js";
+import { i as Paginator } from "./CursorPaginator-CfeMQCdJ.js";
+import { g as SerializerOutput, n as AnyModelSerializer } from "./index-C55GDIOn.js";
+import { d as APIViewMethod, n as GenericAPIViewOpenAPIDescription, u as APIView } from "./index-DkJtxvKu.js";
+import { TangoResponse } from "@danceroutine/tango-core";
+import { ManagerLike, QuerySet } from "@danceroutine/tango-orm";
+
+//#region src/view/GenericAPIView.d.ts
+type SearchFieldRef<TModel extends Record<string, unknown>> = Extract<keyof TModel, string> | string;
+interface GenericAPIViewConfig<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> {
+  serializer: TSerializer;
+  filters?: FilterSet<TModel>;
+  orderingFields?: (keyof TModel)[];
+  searchFields?: SearchFieldRef<TModel>[];
+  lookupField?: keyof TModel;
+  lookupParam?: string;
+  paginatorFactory?: (queryset: QuerySet<TModel>) => Paginator<TModel, SerializerOutput<TSerializer>>;
+}
+/**
+ * Generic API base class that centralizes query/build/validation helpers.
+ */
+declare abstract class GenericAPIView<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends APIView {
+  protected readonly serializerClass: TSerializer;
+  protected readonly filters?: FilterSet<TModel>;
+  protected readonly orderingFields: readonly (keyof TModel)[];
+  protected readonly searchFields: readonly SearchFieldRef<TModel>[];
+  protected readonly lookupField?: keyof TModel;
+  protected readonly lookupParam: string;
+  protected readonly paginatorFactory?: (queryset: QuerySet<TModel>) => Paginator<TModel, SerializerOutput<TSerializer>>;
+  private serializer?;
+  constructor(config: GenericAPIViewConfig<TModel, TSerializer>);
+  /**
+   * Return the serializer class that owns this resource contract.
+   */
+  getSerializerClass(): TSerializer;
+  /**
+   * Return the serializer instance for the current resource.
+   */
+  getSerializer(): InstanceType<TSerializer>;
+  /**
+   * Describe the public HTTP contract that this resource contributes to OpenAPI generation.
+   */
+  describeOpenAPI(): GenericAPIViewOpenAPIDescription<TModel, TSerializer>;
+  protected getManager(): ManagerLike<TModel>;
+  protected getOutputSchema(): TSerializer['outputSchema'];
+  protected getCreateSchema(): TSerializer['createSchema'];
+  protected getUpdateSchema(): TSerializer['updateSchema'];
+  protected getLookupField(): keyof TModel;
+  protected getLookupValue(ctx: RequestContext): string | null;
+  protected getPaginator(queryset: QuerySet<TModel>): Paginator<TModel, SerializerOutput<TSerializer>>;
+  protected performList(ctx: RequestContext): Promise<TangoResponse>;
+  protected performCreate(ctx: RequestContext): Promise<TangoResponse>;
+  protected performRetrieve(ctx: RequestContext): Promise<TangoResponse>;
+  protected performUpdate(ctx: RequestContext): Promise<TangoResponse>;
+  protected performDestroy(ctx: RequestContext): Promise<TangoResponse>;
+  protected handleError(error: unknown): TangoResponse;
+  private requireModelMetadata;
+  private getLookupFieldFromMetadata;
+}
+//#endregion
+//#region src/view/mixins/ListModelMixin.d.ts
+/**
+ * Mixin that wires `GET` requests to the generic list implementation.
+ */
+declare abstract class ListModelMixin<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends GenericAPIView<TModel, TSerializer> {
+  protected list(ctx: RequestContext): Promise<TangoResponse>;
+  protected get(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/mixins/CreateModelMixin.d.ts
+/**
+ * Mixin that wires `POST` requests to the generic create implementation.
+ */
+declare abstract class CreateModelMixin<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends GenericAPIView<TModel, TSerializer> {
+  protected create(ctx: RequestContext): Promise<TangoResponse>;
+  protected post(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/mixins/RetrieveModelMixin.d.ts
+/**
+ * Mixin that wires `GET` requests to the generic retrieve implementation.
+ */
+declare abstract class RetrieveModelMixin<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends GenericAPIView<TModel, TSerializer> {
+  protected retrieve(ctx: RequestContext): Promise<TangoResponse>;
+  protected get(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/mixins/UpdateModelMixin.d.ts
+/**
+ * Mixin that wires `PUT` and `PATCH` requests to the generic update implementation.
+ */
+declare abstract class UpdateModelMixin<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends GenericAPIView<TModel, TSerializer> {
+  protected update(ctx: RequestContext): Promise<TangoResponse>;
+  protected put(ctx: RequestContext): Promise<TangoResponse>;
+  protected patch(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/mixins/DestroyModelMixin.d.ts
+/**
+ * Mixin that wires `DELETE` requests to the generic destroy implementation.
+ */
+declare abstract class DestroyModelMixin<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends GenericAPIView<TModel, TSerializer> {
+  protected destroy(ctx: RequestContext): Promise<TangoResponse>;
+  protected delete(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/generics/ListAPIView.d.ts
+/**
+ * Generic API view for endpoints that only expose a list operation.
+ */
+declare abstract class ListAPIView<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends ListModelMixin<TModel, TSerializer> {
+  protected get(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/generics/CreateAPIView.d.ts
+/**
+ * Generic API view for endpoints that only support resource creation.
+ */
+declare abstract class CreateAPIView<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends CreateModelMixin<TModel, TSerializer> {
+  protected post(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/generics/RetrieveAPIView.d.ts
+/**
+ * Generic API view for endpoints that retrieve a single resource by lookup.
+ */
+declare abstract class RetrieveAPIView<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends RetrieveModelMixin<TModel, TSerializer> {
+  protected get(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/generics/ListCreateAPIView.d.ts
+/**
+ * Generic API view for collection endpoints that list and create resources.
+ */
+declare abstract class ListCreateAPIView<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends GenericAPIView<TModel, TSerializer> {
+  protected get(ctx: RequestContext): Promise<TangoResponse>;
+  protected post(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/generics/RetrieveUpdateAPIView.d.ts
+/**
+ * Generic API view for endpoints that retrieve and update a single resource.
+ */
+declare abstract class RetrieveUpdateAPIView<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends GenericAPIView<TModel, TSerializer> {
+  protected get(ctx: RequestContext): Promise<TangoResponse>;
+  protected put(ctx: RequestContext): Promise<TangoResponse>;
+  protected patch(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/generics/RetrieveDestroyAPIView.d.ts
+/**
+ * Generic API view for endpoints that retrieve and delete a single resource.
+ */
+declare abstract class RetrieveDestroyAPIView<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends GenericAPIView<TModel, TSerializer> {
+  protected get(ctx: RequestContext): Promise<TangoResponse>;
+  protected delete(ctx: RequestContext): Promise<TangoResponse>;
+}
+//#endregion
+//#region src/view/generics/RetrieveUpdateDestroyAPIView.d.ts
+/**
+ * Generic API view for full detail endpoints that retrieve, update, and delete.
+ */
+declare abstract class RetrieveUpdateDestroyAPIView<TModel extends Record<string, unknown>, TSerializer extends AnyModelSerializer<TModel>> extends GenericAPIView<TModel, TSerializer> {
+  protected get(ctx: RequestContext): Promise<TangoResponse>;
+  protected put(ctx: RequestContext): Promise<TangoResponse>;
+  protected patch(ctx: RequestContext): Promise<TangoResponse>;
+  protected delete(ctx: RequestContext): Promise<TangoResponse>;
+}
+declare namespace index_d_exports {
+  export { APIView, APIViewMethod, CreateAPIView, CreateModelMixin, DestroyModelMixin, GenericAPIView, GenericAPIViewConfig, GenericAPIViewOpenAPIDescription, ListAPIView, ListCreateAPIView, ListModelMixin, RetrieveAPIView, RetrieveDestroyAPIView, RetrieveModelMixin, RetrieveUpdateAPIView, RetrieveUpdateDestroyAPIView, UpdateModelMixin };
+}
+//#endregion
+export { ListCreateAPIView as a, ListAPIView as c, RetrieveModelMixin as d, CreateModelMixin as f, GenericAPIViewConfig as h, RetrieveUpdateAPIView as i, DestroyModelMixin as l, GenericAPIView as m, RetrieveUpdateDestroyAPIView as n, RetrieveAPIView as o, ListModelMixin as p, RetrieveDestroyAPIView as r, CreateAPIView as s, index_d_exports as t, UpdateModelMixin as u };
+//# sourceMappingURL=index-Bg6TtnmQ.d.ts.map

package/dist/index-C55GDIOn.d.ts

@@ -0,0 +1,222 @@
+import { ManagerLike, ManyToManyRelatedManager } from "@danceroutine/tango-orm";
+import { z } from "zod";
+
+//#region src/resource/ResourceModelLike.d.ts
+type ResourceModelFieldMetadata = {
+  name: string;
+  type: string;
+  notNull?: boolean;
+  default?: unknown;
+  primaryKey?: boolean;
+};
+type ResourceModelMetadata = {
+  name: string;
+  fields: ResourceModelFieldMetadata[];
+};
+type ResourceModelLike<TModel extends Record<string, unknown>, TModelRecord extends Record<string, unknown> = TModel> = {
+  /**
+   * Resource-layer contracts own the outward representation. The underlying
+   * model may materialize a richer ORM record, so the manager record type is kept
+   * separate from the serializer-facing model shape.
+   */
+  readonly objects: ManagerLike<TModelRecord>;
+  readonly metadata?: ResourceModelMetadata;
+  readonly __tangoModelShape?: TModel;
+};
+//#endregion
+//#region src/serializer/Serializer.d.ts
+type SerializerSchema = z.ZodTypeAny;
+type SerializerClass<TCreateSchema extends SerializerSchema = SerializerSchema, TUpdateSchema extends SerializerSchema = SerializerSchema, TOutputSchema extends SerializerSchema = SerializerSchema, TRecord = unknown> = {
+  new (): Serializer<TCreateSchema, TUpdateSchema, TOutputSchema, TRecord>;
+  readonly createSchema: TCreateSchema;
+  readonly updateSchema: TUpdateSchema;
+  readonly outputSchema: TOutputSchema;
+  readonly outputResolvers?: SerializerOutputResolvers<TRecord>;
+};
+type AnySerializerClass = SerializerClass<SerializerSchema, SerializerSchema, SerializerSchema, any>;
+type SerializerCreateInput<TSerializer extends AnySerializerClass> = z.output<TSerializer['createSchema']>;
+type SerializerUpdateInput<TSerializer extends AnySerializerClass> = z.output<TSerializer['updateSchema']>;
+type SerializerOutput<TSerializer extends AnySerializerClass> = z.output<TSerializer['outputSchema']>;
+type SerializerOutputResolver<TRecord = unknown> = (record: TRecord) => unknown | Promise<unknown>;
+type SerializerOutputResolvers<TRecord = unknown> = Record<string, SerializerOutputResolver<TRecord>>;
+/**
+ * DRF-inspired base serializer backed by Zod schemas.
+ *
+ * Tango serializers keep Zod as the source of truth for validation and type
+ * inference while centralizing create, update, and representation workflows in
+ * one class-owned contract.
+ */
+declare abstract class Serializer<TCreateSchema extends SerializerSchema, TUpdateSchema extends SerializerSchema, TOutputSchema extends SerializerSchema, TRecord = unknown> {
+  static readonly createSchema: SerializerSchema;
+  static readonly updateSchema: SerializerSchema;
+  static readonly outputSchema: SerializerSchema;
+  static readonly outputResolvers: SerializerOutputResolvers< // oxlint-disable-next-line typescript/no-explicit-any
+  any> | undefined;
+  /**
+   * Return the serializer class for the current instance.
+   */
+  getSerializerClass(): SerializerClass<TCreateSchema, TUpdateSchema, TOutputSchema, TRecord>;
+  /**
+   * Return the Zod schema used for create payloads.
+   */
+  getCreateSchema(): TCreateSchema;
+  /**
+   * Return the Zod schema used for update payloads.
+   */
+  getUpdateSchema(): TUpdateSchema;
+  /**
+   * Return the Zod schema used for serialized output.
+   */
+  getOutputSchema(): TOutputSchema;
+  /**
+   * Return the resolver map used to enrich serializer output fields before
+   * the outward Zod schema parses the final response shape.
+   */
+  getOutputResolvers(): SerializerOutputResolvers<TRecord>;
+  /**
+   * Validate unknown input for create workflows.
+   */
+  deserializeCreate(input: unknown): z.output<TCreateSchema>;
+  /**
+   * Validate unknown input for update workflows.
+   */
+  deserializeUpdate(input: unknown): z.output<TUpdateSchema>;
+  /**
+   * Convert a persisted record into its outward-facing representation.
+   *
+   * @deprecated Use `serialize(...)` instead so serializer-owned output
+   * resolvers run before the outward Zod schema parses the response shape.
+   */
+  toRepresentation(record: TRecord): z.output<TOutputSchema>;
+  /**
+   * Resolve serializer-owned output fields and parse the outward response
+   * contract.
+   */
+  serialize(record: TRecord): Promise<z.output<TOutputSchema>>;
+  /**
+   * Serialize many records through the same outward response contract.
+   */
+  serializeMany(records: readonly TRecord[]): Promise<z.output<TOutputSchema>[]>;
+  private applyOutputResolvers;
+}
+//#endregion
+//#region src/serializer/internal/InternalSerializerRelationKind.d.ts
+declare const InternalSerializerRelationKind: {
+  readonly MANY_TO_MANY: "manyToMany";
+};
+declare const InternalManyToManyReadStrategyKind: {
+  readonly PK_LIST: "pkList";
+  readonly NESTED: "nested";
+};
+declare const InternalManyToManyWriteStrategyKind: {
+  readonly PK_LIST: "pkList";
+  readonly SLUG_LIST: "slugList";
+};
+//#endregion
+//#region src/serializer/relation.d.ts
+type AnyRecord = Record<string, unknown>;
+type ManyToManyManagerKeys<TRecord extends AnyRecord> = Extract<{ [K in keyof TRecord]: TRecord[K] extends ManyToManyRelatedManager<AnyRecord> ? K : never }[keyof TRecord], string>;
+type ManyToManyTargetRow<TRecord extends AnyRecord, TFieldName extends ManyToManyManagerKeys<TRecord>> = TRecord[TFieldName] extends ManyToManyRelatedManager<infer TTarget extends AnyRecord> ? TTarget : never;
+type ManyToManyPkListStrategy = {
+  kind: typeof InternalManyToManyReadStrategyKind.PK_LIST | typeof InternalManyToManyWriteStrategyKind.PK_LIST;
+};
+type ManyToManyNestedStrategy = {
+  kind: typeof InternalManyToManyReadStrategyKind.NESTED;
+  schema: z.ZodTypeAny;
+};
+type ManyToManySlugListStrategy<TTarget extends AnyRecord> = {
+  kind: typeof InternalManyToManyWriteStrategyKind.SLUG_LIST;
+  model: ResourceModelLike<any, any>;
+  lookupField: Extract<keyof TTarget, string>;
+  createIfMissing?: boolean;
+  buildCreateInput?: (value: string) => Partial<TTarget>;
+};
+type ManyToManyReadStrategy = ManyToManyPkListStrategy | ManyToManyNestedStrategy;
+type ManyToManyWriteStrategy<TTarget extends AnyRecord> = ManyToManyPkListStrategy | ManyToManySlugListStrategy<TTarget>;
+type ManyToManyRelationField<TRecord extends AnyRecord, TFieldName extends ManyToManyManagerKeys<TRecord>> = {
+  kind: typeof InternalSerializerRelationKind.MANY_TO_MANY;
+  read: ManyToManyReadStrategy;
+  write: ManyToManyWriteStrategy<ManyToManyTargetRow<TRecord, TFieldName>>;
+};
+type ModelSerializerRelationFields<TRecord extends AnyRecord> = Partial<{ [K in ManyToManyManagerKeys<TRecord>]: ManyToManyRelationField<TRecord, K> }>;
+declare function pkList(): ManyToManyPkListStrategy;
+declare function nested(schema: z.ZodTypeAny): ManyToManyNestedStrategy;
+declare function slugList<TTarget extends AnyRecord>(options: Omit<ManyToManySlugListStrategy<TTarget>, 'kind'>): ManyToManySlugListStrategy<TTarget>;
+declare function manyToMany(config?: Partial<Pick<ManyToManyRelationField<any, any>, 'read' | 'write'>>): ManyToManyRelationField<any, any>;
+type RelationHelpers = {
+  manyToMany: typeof manyToMany;
+  pkList: typeof pkList;
+  nested: typeof nested;
+  slugList: typeof slugList;
+};
+declare const relation: RelationHelpers;
+//#endregion
+//#region src/serializer/ModelSerializer.d.ts
+type ModelSerializerClass<TModel extends Record<string, unknown> = Record<string, unknown>, TCreateSchema extends SerializerSchema = SerializerSchema, TUpdateSchema extends SerializerSchema = SerializerSchema, TOutputSchema extends SerializerSchema = SerializerSchema, TModelRecord extends Record<string, unknown> = TModel> = SerializerClass<TCreateSchema, TUpdateSchema, TOutputSchema, TModelRecord> & {
+  new (): ModelSerializer<TModel, TCreateSchema, TUpdateSchema, TOutputSchema, TModelRecord>;
+  readonly model?: ResourceModelLike<TModel, TModelRecord>;
+  readonly relationFields?: ModelSerializerRelationFields<TModelRecord>;
+};
+type AnyModelSerializer<TModel extends Record<string, unknown> = Record<string, unknown>> = ModelSerializerClass<TModel, SerializerSchema, SerializerSchema, SerializerSchema, any>;
+type AnyModelSerializerClass = AnyModelSerializer;
+/**
+ * Zod-backed serializer with default model-manager persistence behavior.
+ */
+declare abstract class ModelSerializer<TModel extends Record<string, unknown>, TCreateSchema extends SerializerSchema, TUpdateSchema extends SerializerSchema, TOutputSchema extends SerializerSchema, TModelRecord extends Record<string, unknown> = TModel> extends Serializer<TCreateSchema, TUpdateSchema, TOutputSchema, TModelRecord> {
+  static readonly model?: unknown;
+  static readonly relationFields: ModelSerializerRelationFields<Record<string, unknown>> | undefined;
+  /**
+   * Return the Tango model backing this serializer.
+   */
+  getModel(): ResourceModelLike<TModel, TModelRecord>;
+  /**
+   * Return the manager used for create and update workflows.
+   */
+  getManager(): ManagerLike<TModelRecord>;
+  /**
+   * Return the declarative relation-field map for this serializer.
+   */
+  getRelationFields(): ModelSerializerRelationFields<TModelRecord>;
+  /**
+   * Merge relation-field read resolvers into the serializer output path.
+   */
+  getOutputResolvers(): SerializerOutputResolvers<TModelRecord>;
+  /**
+   * Validate, enrich, persist, and serialize a create workflow.
+   */
+  create(input: unknown): Promise<SerializerOutput<ModelSerializerClass<TModel, TCreateSchema, TUpdateSchema, TOutputSchema, TModelRecord>>>;
+  /**
+   * Validate, enrich, persist, and serialize an update workflow.
+   */
+  update(id: TModelRecord[keyof TModelRecord], input: unknown): Promise<SerializerOutput<ModelSerializerClass<TModel, TCreateSchema, TUpdateSchema, TOutputSchema, TModelRecord>>>;
+  /**
+   * Override to normalize create input for this resource workflow before the
+   * manager call.
+   *
+   * Model-owned persistence rules belong in model hooks so they also run for
+   * scripts and direct manager usage.
+   */
+  protected beforeCreate(data: SerializerCreateInput<ModelSerializerClass<TModel, TCreateSchema, TUpdateSchema, TOutputSchema, TModelRecord>>): Promise<Partial<TModelRecord>>;
+  /**
+   * Override to normalize update input for this resource workflow before the
+   * manager call.
+   *
+   * Model-owned persistence rules belong in model hooks so they also run for
+   * scripts and direct manager usage.
+   */
+  protected beforeUpdate(_id: TModelRecord[keyof TModelRecord], data: SerializerUpdateInput<ModelSerializerClass<TModel, TCreateSchema, TUpdateSchema, TOutputSchema, TModelRecord>>): Promise<Partial<TModelRecord>>;
+  private extractRelationWrites;
+  private stripRelationFields;
+  private applyRelationWrites;
+  private serializeRelationField;
+  private syncManyToManyRelation;
+  private resolveWriteTargets;
+  private getManyToManyManager;
+  private getManyToManyRelationMeta;
+}
+declare namespace index_d_exports {
+  export { AnyModelSerializer, AnyModelSerializerClass, AnySerializerClass, ManyToManyManagerKeys, ManyToManyReadStrategy, ManyToManyRelationField, ManyToManyWriteStrategy, ModelSerializer, ModelSerializerClass, ModelSerializerRelationFields, Serializer, SerializerClass, SerializerCreateInput, SerializerOutput, SerializerOutputResolver, SerializerOutputResolvers, SerializerSchema, SerializerUpdateInput, relation };
+}
+//#endregion
+export { ResourceModelMetadata as C, ResourceModelLike as S, SerializerOutputResolver as _, ModelSerializerClass as a, SerializerUpdateInput as b, ManyToManyRelationField as c, relation as d, AnySerializerClass as f, SerializerOutput as g, SerializerCreateInput as h, ModelSerializer as i, ManyToManyWriteStrategy as l, SerializerClass as m, AnyModelSerializer as n, ManyToManyManagerKeys as o, Serializer as p, AnyModelSerializerClass as r, ManyToManyReadStrategy as s, index_d_exports as t, ModelSerializerRelationFields as u, SerializerOutputResolvers as v, ResourceModelFieldMetadata as x, SerializerSchema as y };
+//# sourceMappingURL=index-C55GDIOn.d.ts.map

package/dist/index-CiIB-1Ac.d.ts

@@ -0,0 +1,123 @@
+import { TangoQueryParams } from "@danceroutine/tango-core";
+import { FilterInput, FilterValue, LookupType } from "@danceroutine/tango-orm";
+
+//#region src/filters/internal/InternalFilterType.d.ts
+declare const InternalFilterType: {
+  readonly SCALAR: "scalar";
+  readonly ILIKE: "ilike";
+  readonly RANGE: "range";
+  readonly IN: "in";
+  readonly CUSTOM: "custom";
+};
+//#endregion
+//#region src/filters/FilterType.d.ts
+type FilterType = (typeof InternalFilterType)[keyof typeof InternalFilterType];
+//#endregion
+//#region src/filters/internal/InternalRangeOperator.d.ts
+declare const InternalRangeOperator: {
+  readonly GTE: "gte";
+  readonly LTE: "lte";
+  readonly GT: "gt";
+  readonly LT: "lt";
+};
+//#endregion
+//#region src/filters/RangeOperator.d.ts
+type RangeOperator = (typeof InternalRangeOperator)[keyof typeof InternalRangeOperator];
+//#endregion
+//#region src/filters/FilterSet.d.ts
+type FilterFieldRef<T extends Record<string, unknown>> = Extract<keyof T, string> | string;
+/**
+ * Configuration for how a query parameter should be resolved into a filter.
+ * Supports scalar equality, case-insensitive search, range comparisons, IN queries, and custom logic.
+ */
+type FilterResolver<T extends Record<string, unknown>> = {
+  type: typeof InternalFilterType.SCALAR;
+  column: FilterFieldRef<T>;
+} | {
+  type: typeof InternalFilterType.ILIKE;
+  columns: FilterFieldRef<T>[];
+} | {
+  type: typeof InternalFilterType.RANGE;
+  column: FilterFieldRef<T>;
+  op: RangeOperator;
+} | {
+  type: typeof InternalFilterType.IN;
+  column: FilterFieldRef<T>;
+} | {
+  type: typeof InternalFilterType.CUSTOM;
+  apply: (value: string | string[] | undefined) => FilterInput<T> | undefined;
+};
+type FilterLookup = LookupType;
+type FilterValueParser = (raw: string | string[]) => FilterValue | FilterValue[] | undefined;
+type FieldFilterDeclaration = true | readonly FilterLookup[] | {
+  lookups?: readonly FilterLookup[];
+  param?: string;
+  parse?: FilterValueParser;
+};
+type AliasFilterDeclaration<T extends Record<string, unknown>> = FilterResolver<T> | {
+  field: FilterFieldRef<T>;
+  lookup?: FilterLookup;
+  parse?: FilterValueParser;
+} | {
+  fields: readonly FilterFieldRef<T>[];
+  lookup?: FilterLookup;
+  parse?: FilterValueParser;
+};
+interface FilterSetDefineConfig<T extends Record<string, unknown>> {
+  fields?: Partial<Record<string, FieldFilterDeclaration>>;
+  aliases?: Record<string, AliasFilterDeclaration<T>>;
+  parsers?: Partial<Record<string, FilterValueParser>>;
+  all?: '__all__';
+}
+/**
+ * Declarative query-param to filter translation.
+ *
+ * A `FilterSet` lets viewsets expose safe, explicit filtering behavior
+ * without leaking raw ORM filter syntax to request handlers.
+ */
+declare class FilterSet<T extends Record<string, unknown>> {
+  private readonly spec;
+  private readonly allowAllParams;
+  static readonly BRAND: "tango.resources.filter_set";
+  readonly __tangoBrand: typeof FilterSet.BRAND;
+  /**
+   * Resolve matching query parameters into ORM filter inputs.
+   */
+  constructor(spec: Record<string, FilterResolver<T>>, allowAllParams?: boolean);
+  /**
+   * Build a filter set from Django-style field declarations.
+   */
+  static define<T extends Record<string, unknown>>(config: FilterSetDefineConfig<T>): FilterSet<T>;
+  /**
+   * Narrow an unknown value to `FilterSet`.
+   */
+  static isFilterSet<T extends Record<string, unknown>>(value: unknown): value is FilterSet<T>;
+  private static normalizeDefineConfig;
+  private static addFieldDeclaration;
+  private static isLookupArray;
+  private static normalizeAliasDeclaration;
+  private static isFilterResolverDeclaration;
+  private static createMultiFieldResolver;
+  private static createLookupResolver;
+  private static resolveLookupFilter;
+  private static resolveLookupParam;
+  private static resolveParserValue;
+  private static toScalarString;
+  /**
+   * Return a new filter set with parser-aware scalar/range/in resolvers for matching fields.
+   */
+  withFieldParsers(parsers: Partial<Record<string, FilterValueParser>>): FilterSet<T>;
+  /**
+   * Apply all configured resolvers against query params.
+   */
+  apply(params: TangoQueryParams): FilterInput<T>[];
+  private buildAllResolver;
+  private resolveFilter;
+  private applyFieldParserOverride;
+}
+declare namespace index_d_exports {
+  export { AliasFilterDeclaration, FieldFilterDeclaration, FilterLookup, FilterResolver, FilterSet, FilterSetDefineConfig, FilterType, FilterValueParser, RangeOperator };
+}
+//#endregion
+export { FilterResolver as a, FilterValueParser as c, FilterLookup as i, RangeOperator as l, AliasFilterDeclaration as n, FilterSet as o, FieldFilterDeclaration as r, FilterSetDefineConfig as s, index_d_exports as t, FilterType as u };
+//# sourceMappingURL=index-CiIB-1Ac.d.ts.map