# AntelopeJS Interfaces

> The documentation hub for AntelopeJS interfaces: versioned contracts that modules consume and provider modules implement (the ports of a hexagonal architecture). Each interface has its guides and API reference, and the module catalogue lists the available implementations.

## Documentation Sets

- [Full documentation](https://interfaces.antelopejs.com/llms-full.txt): Every page of every interface's documentation as one Markdown file.

## API

- [Build HTTP endpoints](https://interfaces.antelopejs.com/docs/api/introduction)
- [Controllers and routes](https://interfaces.antelopejs.com/docs/api/controllers): Use a controller to group endpoints under one path. Start with a method that returns a value; add hooks only when several routes need the same preparation or response handling.
- [Request bodies and responses](https://interfaces.antelopejs.com/docs/api/http-handling): Return a plain value for an ordinary response. Use HTTPResult when you need a status code, headers, or a stream, and RequestContext when you need the underlying Node.js request or response.
- [Read and transform request data](https://interfaces.antelopejs.com/docs/api/parameters): A parameter decorator supplies an argument to your handler from the request. Start with one source per argument, then add a transformation or validation step when the handler needs something other than the raw value.

## API Util

- [Validate and throttle API requests](https://interfaces.antelopejs.com/docs/api-util/introduction)

## Auth

- [Authenticate API requests](https://interfaces.antelopejs.com/docs/auth/introduction)
- [Authentication and authorization](https://interfaces.antelopejs.com/docs/auth/authentication): Authentication establishes trust in a token. Authorization decides what its holder may do. This interface connects token verification to API parameter injection; your application supplies credential checks, payload validation, and access rules.
- [Token Handling](https://interfaces.antelopejs.com/docs/auth/token-handling): The Interface Auth provides functions for generating and validating authentication tokens. These functions serve as the foundation for the authentication system.
- [Require authentication in controllers](https://interfaces.antelopejs.com/docs/auth/parameter-decoration): Use a parameter decorator when one handler needs the payload, a property decorator when several methods need it, or a class decorator when every route must authenticate without receiving the payload. These are alternative scopes, not three steps you must combine.

## Core

- [Connect modules through interfaces](https://interfaces.antelopejs.com/docs/core/introduction)
- [Proxies](https://interfaces.antelopejs.com/docs/core/proxies)
- [Decorators](https://interfaces.antelopejs.com/docs/core/decorators)
- [Metadata](https://interfaces.antelopejs.com/docs/core/metadata)
- [Modules](https://interfaces.antelopejs.com/docs/core/modules)
- [Logging](https://interfaces.antelopejs.com/docs/core/logging)
- [Configuration](https://interfaces.antelopejs.com/docs/core/configuration)
- [Runtime](https://interfaces.antelopejs.com/docs/core/runtime)

## Data API

- [Expose database records through an API](https://interfaces.antelopejs.com/docs/data-api/introduction)
- [Data Controllers](https://interfaces.antelopejs.com/docs/data-api/data-controllers)
- [Routes](https://interfaces.antelopejs.com/docs/data-api/routes)
- [Access Rights](https://interfaces.antelopejs.com/docs/data-api/access-rights)
- [Validators](https://interfaces.antelopejs.com/docs/data-api/validators)
- [Listable Fields](https://interfaces.antelopejs.com/docs/data-api/listable)
- [Foreign Keys](https://interfaces.antelopejs.com/docs/data-api/foreign-keys)
- [Filters](https://interfaces.antelopejs.com/docs/data-api/filters)
- [Modifiers](https://interfaces.antelopejs.com/docs/data-api/modifiers)
- [Joined Fields](https://interfaces.antelopejs.com/docs/data-api/joined)
- [Computed Fields](https://interfaces.antelopejs.com/docs/data-api/computed)

## Database

- [Database](https://interfaces.antelopejs.com/docs/database)
- [Query Types](https://interfaces.antelopejs.com/docs/database/query_types): AQL provides several query classes that form a hierarchy of capabilities. Each class encapsulates a different aspect of database interactions, from full table access down to individual value manipulation.
- [Query Types › Table](https://interfaces.antelopejs.com/docs/database/query_types/table): The Table<T> class represents a database table and provides methods for inserting documents and retrieving them by primary key, secondary index, or range. It extends Selection<T>, inheriting all multi-document operations and stream capabilities.
- [Query Types › Selection](https://interfaces.antelopejs.com/docs/database/query_types/selection): The Selection<T> class represents a set of documents and provides methods for bulk mutation operations. It extends Stream<T>, inheriting all transformation, filtering, and aggregation capabilities.
- [Query Types › SingleSelection](https://interfaces.antelopejs.com/docs/database/query_types/single_selection): The SingleSelection<T> class represents a reference to a single document in a table. It extends Datum<T> and provides methods for updating, replacing, deleting, and monitoring changes to an individual document.
- [Query Types › Stream](https://interfaces.antelopejs.com/docs/database/query_types/stream): The Stream<T> class represents a sequence of documents that can be transformed, filtered, joined, grouped, and aggregated. It extends Query<T[]> and serves as the foundation for collection-based operations in AQL.
- [Query Types › Change Feeds](https://interfaces.antelopejs.com/docs/database/query_types/feed): Change feeds provide real-time notifications when documents are inserted, updated, or deleted. Both Stream<T> and SingleSelection<T> expose a changes() method that returns change events.
- [Query Types › Query](https://interfaces.antelopejs.com/docs/database/query_types/query): The Query<T> class is the base class for all query types in the AQL system. It implements PromiseLike<T>, so queries can be awaited directly, and provides cursor-based async iteration for streaming results.
- [Query Types › Datum](https://interfaces.antelopejs.com/docs/database/query_types/datum): The Datum<T> class represents a single value in the query system. It extends Query<T> and provides methods for accessing fields, applying transformations, and performing foreign key lookups on individual values.
- [Query Types › ValueProxy](https://interfaces.antelopejs.com/docs/database/query_types/valueproxy): The ValueProxy<T> class acts as a proxy to a database value. Operations on a ValueProxy are not executed immediately but are recorded as query stages. ValueProxy objects appear inside callback functions for map, filter, do, update, join, and other query methods.
- [Operations](https://interfaces.antelopejs.com/docs/database/operations): This section covers practical operations you can perform with the AQL interface. These guides walk through schema management, table access, document CRUD, index usage, filtering, and foreign key lookups.
- [Operations › Schema Management](https://interfaces.antelopejs.com/docs/database/operations/database_management): AQL organizes data through schemas and instances. A Schema defines the structure of your database (tables, fields, and indexes). Each schema can have multiple instances, and the underlying module implementation determines how instances map to physical storage.
- [Operations › Table Operations](https://interfaces.antelopejs.com/docs/database/operations/table_operations): Tables are the primary containers for documents in AQL. They are accessed through a SchemaInstance and provide methods for inserting, retrieving, and querying documents.
- [Operations › CRUD Operations](https://interfaces.antelopejs.com/docs/database/operations/crud): CRUD operations (Create, Read, Update, Delete) form the foundation of document management in AQL. All examples assume a schema is already defined and an instance is available.
- [Operations › Index Management](https://interfaces.antelopejs.com/docs/database/operations/indexes): Indexes improve query performance by enabling the database to locate documents quickly based on indexed fields. In AQL, indexes are defined as part of the schema definition.
- [Operations › Filtering and Querying](https://interfaces.antelopejs.com/docs/database/operations/filtering): This guide covers techniques for selecting, comparing, and transforming documents using AQL's filter and ValueProxy capabilities.
- [Operations › Lookup](https://interfaces.antelopejs.com/docs/database/operations/lookup): The lookup method performs a foreign key join, replacing a field in your documents with the referenced data from another table. It is available on both Stream<T> and Datum<T>.
- [Operations › Atomic single-record mutations](https://interfaces.antelopejs.com/docs/database/operations/atomic_mutations): Table.atomicMutation(id, request) checks one immutable, instance-scoped record identity and one condition inside the database mutation. It returns Query<AtomicMutationOutcome>. It does not provide multi-record transactions, a lock service, receipts, or external-effect coordination.
- [Results](https://interfaces.antelopejs.com/docs/database/results): AQL operations return structured result values that communicate what happened during execution. This section covers the result types produced by write operations and change feeds.
- [Results › Insert Results](https://interfaces.antelopejs.com/docs/database/results/write_results): The insert method on Table<T> returns a Query<string[]> that resolves to an array of the generated or provided primary keys for the inserted documents.
- [Results › Index Definitions](https://interfaces.antelopejs.com/docs/database/results/index_changes): In AQL, indexes are defined as part of the schema definition rather than created at runtime. The schema declaration specifies which fields to index and what type of index to use.
- [Results › Table Definitions](https://interfaces.antelopejs.com/docs/database/results/table_changes): In AQL, tables are defined as part of a schema. Each table definition specifies the fields and indexes for that table.
- [Results › Schema and Instance Management](https://interfaces.antelopejs.com/docs/database/results/database_changes): This page covers the Schema, SchemaInstance, and related types that control database structure and lifecycle.
- [Results › Change Events](https://interfaces.antelopejs.com/docs/database/results/value_changes): The Changes<T> interface represents a change event emitted by change feeds. It includes the type of change and the document values before and after the change.

## Database Catalog

- [Database Catalog](https://interfaces.antelopejs.com/docs/database-catalog): Use @antelopejs/interface-database-catalog to discover relations, inspect their structure, and profile aggregate characteristics before mapping an existing database into an application. The catalog describes a provider's connection; it does not open a new connection, register tables, or return raw records.

## Database Decorators

- [Define tables and work with models](https://interfaces.antelopejs.com/docs/database-decorators/introduction)
- [Table Definitions](https://interfaces.antelopejs.com/docs/database-decorators/table-definitions): The Database Decorators package provides a class-based approach to defining database tables. You extend the Table base class, declare each field with TypeScript's declare keyword and the @Field decorator, and use further decorators to configure indexes, relations, and initial data.
- [Table Modifiers](https://interfaces.antelopejs.com/docs/database-decorators/table-modifiers): Table modifiers transform field values as they are stored in and retrieved from the database. They enable transparent encryption, hashing, localization, and custom data transformations. Add modifiers to a table class using the Table.with() method.
- [Data Models](https://interfaces.antelopejs.com/docs/database-decorators/data-models): Data models provide a high-level interface for interacting with database tables. They handle conversion between database records and TypeScript class instances, and expose methods for common CRUD operations.
- [Parameter Decoration](https://interfaces.antelopejs.com/docs/database-decorators/parameter-decoration): The Database Decorators package provides the Model decorator for injecting data model instances into API controller methods. This decorator integrates with the @antelopejs/interface-api package's parameter provider system.

## Email

- [Introduction](https://interfaces.antelopejs.com/docs/email/introduction): Send transactional messages, templates, and batches through one provider-neutral contract. @antelopejs/interface-email defines the request and response types; an implementing module supplies the email provider and its configuration.
- [Sending Emails](https://interfaces.antelopejs.com/docs/email/sending-emails): The interface provides three sending functions: Send for single emails, SendTemplate for template-based emails, and SendBatch for multiple emails in one operation.
- [Attachments](https://interfaces.antelopejs.com/docs/email/attachments): The interface supports four attachment types, each suited to a different source of file data. All types share a common BaseAttachment structure and are passed through the attachments field of EmailParams.

## File Storage

- [Introduction](https://interfaces.antelopejs.com/docs/file-storage/introduction): Let clients transfer bytes directly to storage while your server authorizes uploads and manages file references. @antelopejs/interface-file-storage defines the contract; an implementing module supplies the backend, URL signing, and storage configuration.
- [File Operations](https://interfaces.antelopejs.com/docs/file-storage/file-operations): The interface provides functions for uploading files via presigned URLs, generating download URLs, deleting files, checking existence, and retrieving metadata.
- [Provider Promotion Contract](https://interfaces.antelopejs.com/docs/file-storage/provider-contract): This page is for storage backend authors. Application authors can start with
file operations; their authorization, admission, and
cancellation responsibilities remain in that guide.

## MongoDB

- [Query MongoDB with the shared client](https://interfaces.antelopejs.com/docs/mongodb/introduction)

## Redis

- [Interface Redis Documentation](https://interfaces.antelopejs.com/docs/redis/introduction)

## Redis Scheduler

- [Interface Redis Scheduler Documentation](https://interfaces.antelopejs.com/docs/redis-scheduler/introduction)

## RethinkDB

- [Query RethinkDB through a managed connection](https://interfaces.antelopejs.com/docs/rethinkdb/introduction)

## Stripe

- [Interface Stripe Documentation](https://interfaces.antelopejs.com/docs/stripe/introduction)
- [Payment Processing](https://interfaces.antelopejs.com/docs/stripe/payment-processing): Interface Stripe provides functions for creating payment intents, waiting for their completion, and finalizing payments with chargeable sources.
- [Event Monitoring](https://interfaces.antelopejs.com/docs/stripe/event-monitoring): Interface Stripe provides functions for monitoring payment intent status changes. Watchers receive callbacks whenever a payment intent transitions to a new state, enabling your application to react to successful payments, cancellations, and other status updates.

## Modules

- [Module catalogue](https://interfaces.antelopejs.com/modules): implementations of each interface (API, auth-jwt, data-api, database-decorators, MongoDB, Redis, RethinkDB, Stripe…)

## Optional

- [AntelopeJS Framework](https://framework.antelopejs.com): how modules and interfaces fit together
- [GitHub](https://github.com/antelopejs)