@tmlmobilidade/interfaces 20250325.1729.19

package/dist/src/interfaces/auth/verification-tokens.interface.js

@@ -0,0 +1,45 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { HttpException, HttpStatus } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+class VerificationTokensClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!VerificationTokensClass._instance) {
+            const instance = new VerificationTokensClass();
+            await instance.connect();
+            VerificationTokensClass._instance = instance;
+        }
+        return VerificationTokensClass._instance;
+    }
+    /**
+     * Finds a verification token by its token.
+     *
+     * @param token - The token to find
+     * @returns The verification token or null if not found
+     */
+    async findByToken(token) {
+        return this.findOne({ token });
+    }
+    /**
+     * Disable Update Many
+     */
+    async updateMany() {
+        throw new HttpException(HttpStatus.METHOD_NOT_ALLOWED, 'Method not allowed for verification tokens');
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { expires_at: 1 } },
+            { background: true, key: { token: 1 }, unique: true },
+        ];
+    }
+    getCollectionName() {
+        return 'verification_tokens';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_AUTH';
+    }
+}
+export const verificationTokens = AsyncSingletonProxy(VerificationTokensClass);

package/dist/src/interfaces/files/files.interface.d.ts

@@ -0,0 +1,41 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateFileDto, File, UpdateFileDto } from '@tmlmobilidade/types';
+import { DeleteResult, IndexDescription, InsertOneResult } from 'mongodb';
+declare class FilesClass extends MongoCollectionClass<File, CreateFileDto, UpdateFileDto> {
+    private static _instance;
+    private readonly bucketName;
+    private readonly storageService;
+    private constructor();
+    static getInstance(): Promise<FilesClass>;
+    /**
+     * Deletes a file from the storage service and the database.
+     * @param file_id - The unique identifier of the file in the database.
+     * @returns The file that was deleted.
+     */
+    deleteById(file_id: string): Promise<DeleteResult>;
+    /**
+     * Retrieves the signed URL of a file from the storage service.
+     * @param params - Object containing either `file_id` or `key`.
+     * @param params.file_id - The unique identifier of the file in the database.
+     * @param params.key - The storage key of the file.
+     * @returns The signed URL of the file.
+     * @throws {Error} If neither `file_id` nor `key` is provided.
+     * @throws {HttpException} If `file_id` is provided but the file is not found.
+    */
+    getFileUrl({ file_id, key, }: {
+        file_id?: string;
+        key?: string;
+    }): Promise<string>;
+    /**
+     * Uploads a file to the storage service and inserts it into the database.
+     * @param file - The file to upload.
+     * @param createFileDto - The file type to create.
+     * @returns The file that was uploaded.
+     */
+    upload(file: Buffer, createFileDto: CreateFileDto): Promise<InsertOneResult<File>>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const files: FilesClass;
+export {};

package/dist/src/interfaces/files/files.interface.js

@@ -0,0 +1,129 @@
+/* * */
+import { StorageFactory } from '../../providers/index.js';
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { HttpStatus } from '@tmlmobilidade/lib';
+import { HttpException } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+import { generateRandomString } from '@tmlmobilidade/utils';
+/* * */
+class FilesClass extends MongoCollectionClass {
+    static _instance;
+    bucketName;
+    storageService;
+    constructor() {
+        super();
+        switch (process.env.TML_INTERFACE_FILES_STORAGE_TYPE) {
+            case 'aws':
+                if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_BUCKET_NAME || !process.env.AWS_SECRET_ACCESS_KEY) {
+                    throw new Error('AWS_ACCESS_KEY_ID, AWS_BUCKET_NAME, and AWS_SECRET_ACCESS_KEY must be set');
+                }
+                this.bucketName = process.env.AWS_BUCKET_NAME;
+                this.storageService = StorageFactory.create({
+                    aws_config: {
+                        access_key_id: process.env.AWS_ACCESS_KEY_ID,
+                        bucket_name: process.env.AWS_BUCKET_NAME,
+                        secret_access_key: process.env.AWS_SECRET_ACCESS_KEY,
+                    },
+                    type: 'aws',
+                });
+                break;
+            case 'cloudflare':
+                if (!process.env.CLOUDFLARE_ACCESS_KEY_ID || !process.env.CLOUDFLARE_BUCKET_NAME || !process.env.CLOUDFLARE_SECRET_ACCESS_KEY) {
+                    throw new Error('CLOUDFLARE_ACCESS_KEY_ID, CLOUDFLARE_BUCKET_NAME, and CLOUDFLARE_SECRET_ACCESS_KEY must be set');
+                }
+                this.bucketName = process.env.CLOUDFLARE_BUCKET_NAME;
+                this.storageService = StorageFactory.create({
+                    cloudflare_config: {
+                        access_key_id: process.env.CLOUDFLARE_ACCESS_KEY_ID,
+                        bucket_name: process.env.CLOUDFLARE_BUCKET_NAME,
+                        endpoint: `https://${process.env.CLOUDFLARE_ACCOUNT_ID}.r2.cloudflarestorage.com`,
+                        region: 'auto',
+                        secret_access_key: process.env.CLOUDFLARE_SECRET_ACCESS_KEY,
+                    },
+                    type: 'cloudflare',
+                });
+                break;
+            default:
+                throw new Error(`Invalid storage type: ${process.env.TML_INTERFACE_FILES_STORAGE_TYPE}`);
+        }
+    }
+    static async getInstance() {
+        if (!FilesClass._instance) {
+            const instance = new FilesClass();
+            await instance.connect();
+            FilesClass._instance = instance;
+        }
+        return FilesClass._instance;
+    }
+    /**
+     * Deletes a file from the storage service and the database.
+     * @param file_id - The unique identifier of the file in the database.
+     * @returns The file that was deleted.
+     */
+    async deleteById(file_id) {
+        const file = await this.findOne({ _id: file_id });
+        if (!file) {
+            throw new HttpException(HttpStatus.NOT_FOUND, 'File not found');
+        }
+        await this.storageService.deleteFile(`${file.scope}/${file.resource_id}/${file._id}`);
+        return await super.deleteById(file_id);
+    }
+    /**
+     * Retrieves the signed URL of a file from the storage service.
+     * @param params - Object containing either `file_id` or `key`.
+     * @param params.file_id - The unique identifier of the file in the database.
+     * @param params.key - The storage key of the file.
+     * @returns The signed URL of the file.
+     * @throws {Error} If neither `file_id` nor `key` is provided.
+     * @throws {HttpException} If `file_id` is provided but the file is not found.
+    */
+    async getFileUrl({ file_id, key, }) {
+        if (!file_id && !key) {
+            throw new Error('Either "file_id" or "key" must be provided');
+        }
+        // If `file_id` is provided, fetch the file and use its key
+        if (file_id) {
+            const file = await this.findOne({ _id: file_id });
+            if (!file) {
+                throw new HttpException(HttpStatus.NOT_FOUND, 'File not found');
+            }
+            key = `${file.scope}/${file.resource_id}/${file._id}`; // Use the file's storage key
+        }
+        // Check if key exists
+        const keyExists = await this.storageService.fileExists(key);
+        if (!keyExists) {
+            throw new HttpException(HttpStatus.NOT_FOUND, `Key ${key} does not exist in bucket ${this.bucketName}`);
+        }
+        // At this point, `key` must exist
+        return this.storageService.getFileUrl(key);
+    }
+    /**
+     * Uploads a file to the storage service and inserts it into the database.
+     * @param file - The file to upload.
+     * @param createFileDto - The file type to create.
+     * @returns The file that was uploaded.
+     */
+    async upload(file, createFileDto) {
+        const _id = generateRandomString({ length: 5 });
+        await this.storageService.uploadFile(`${createFileDto.scope}/${createFileDto.resource_id}/${_id}`, file);
+        return await this.insertOne({ ...createFileDto, _id });
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { created_by: 1 } },
+            { background: true, key: { updated_by: 1 } },
+            { background: true, key: { name: 1 } },
+            { background: true, key: { type: 1 } },
+            { background: true, key: { created_at: -1 } },
+            { background: true, key: { updated_at: -1 } },
+        ];
+    }
+    getCollectionName() {
+        return 'files';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_FILES';
+    }
+}
+/* * */
+export const files = AsyncSingletonProxy(FilesClass);

package/dist/src/interfaces/hashed-shapes/hashed-shapes.interface.d.ts

@@ -0,0 +1,13 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateHashedShapeDto, HashedShape, UpdateHashedShapeDto } from '@tmlmobilidade/types';
+import { IndexDescription } from 'mongodb';
+declare class HashedShapesClass extends MongoCollectionClass<HashedShape, CreateHashedShapeDto, UpdateHashedShapeDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<HashedShapesClass>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const hashedShapes: HashedShapesClass;
+export {};

package/dist/src/interfaces/hashed-shapes/hashed-shapes.interface.js

@@ -0,0 +1,31 @@
+/* * */
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+/* * */
+class HashedShapesClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!HashedShapesClass._instance) {
+            const instance = new HashedShapesClass();
+            await instance.connect();
+            HashedShapesClass._instance = instance;
+        }
+        return HashedShapesClass._instance;
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { agency_id: 1 } },
+        ];
+    }
+    getCollectionName() {
+        return 'hashed_shapes';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_HASHED_SHAPES';
+    }
+}
+/* * */
+export const hashedShapes = AsyncSingletonProxy(HashedShapesClass);

package/dist/src/interfaces/hashed-trips/hashed-trips.interface.d.ts

@@ -0,0 +1,13 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateHashedTripDto, HashedTrip, UpdateHashedTripDto } from '@tmlmobilidade/types';
+import { IndexDescription } from 'mongodb';
+declare class HashedTripsClass extends MongoCollectionClass<HashedTrip, CreateHashedTripDto, UpdateHashedTripDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<HashedTripsClass>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const hashedTrips: HashedTripsClass;
+export {};

package/dist/src/interfaces/hashed-trips/hashed-trips.interface.js

@@ -0,0 +1,32 @@
+/* * */
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+/* * */
+class HashedTripsClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!HashedTripsClass._instance) {
+            const instance = new HashedTripsClass();
+            await instance.connect();
+            HashedTripsClass._instance = instance;
+        }
+        return HashedTripsClass._instance;
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { agency_id: 1 } },
+            { background: true, key: { line_id: 1 } },
+        ];
+    }
+    getCollectionName() {
+        return 'hashed_trips';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_HASHED_TRIPS';
+    }
+}
+/* * */
+export const hashedTrips = AsyncSingletonProxy(HashedTripsClass);

package/dist/src/interfaces/index.d.ts

@@ -0,0 +1,19 @@
+export * from './agencies/agencies.interface.js';
+export * from './alerts/alerts.interface.js';
+export * from './apex-t11/apex-t11.interface.js';
+export * from './apex-t19/apex-t19.interface.js';
+export * from './auth/roles.interface.js';
+export * from './auth/sessions.interface.js';
+export * from './auth/users.interface.js';
+export * from './auth/verification-tokens.interface.js';
+export * from './files/files.interface.js';
+export * from './hashed-shapes/hashed-shapes.interface.js';
+export * from './hashed-trips/hashed-trips.interface.js';
+export * from './localities/localities.interface.js';
+export * from './municipalities/municipalities.interface.js';
+export * from './organizations/organizations.interface.js';
+export * from './plans/plans.interface.js';
+export * from './rides/rides.interface.js';
+export * from './stops/stops.interface.js';
+export * from './vehicle-events/vehicle-events.interface.js';
+export * from './zones/zones.interface.js';

package/dist/src/interfaces/index.js

@@ -0,0 +1,20 @@
+/* * */
+export * from './agencies/agencies.interface.js';
+export * from './alerts/alerts.interface.js';
+export * from './apex-t11/apex-t11.interface.js';
+export * from './apex-t19/apex-t19.interface.js';
+export * from './auth/roles.interface.js';
+export * from './auth/sessions.interface.js';
+export * from './auth/users.interface.js';
+export * from './auth/verification-tokens.interface.js';
+export * from './files/files.interface.js';
+export * from './hashed-shapes/hashed-shapes.interface.js';
+export * from './hashed-trips/hashed-trips.interface.js';
+export * from './localities/localities.interface.js';
+export * from './municipalities/municipalities.interface.js';
+export * from './organizations/organizations.interface.js';
+export * from './plans/plans.interface.js';
+export * from './rides/rides.interface.js';
+export * from './stops/stops.interface.js';
+export * from './vehicle-events/vehicle-events.interface.js';
+export * from './zones/zones.interface.js';

package/dist/src/interfaces/localities/localities.interface.d.ts

@@ -0,0 +1,28 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateLocalityDto, Locality, UpdateLocalityDto } from '@tmlmobilidade/types';
+import { IndexDescription } from 'mongodb';
+declare class LocalitiesClass extends MongoCollectionClass<Locality, CreateLocalityDto, UpdateLocalityDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<LocalitiesClass>;
+    /**
+     * Finds a locality by its code
+     *
+     * @param code - The code of the locality to find
+     * @returns A promise that resolves to the matching locality document or null if not found
+     */
+    findByCode(code: string): Promise<import("mongodb").WithId<Locality> | null>;
+    /**
+     * Updates a locality by its code
+     *
+     * @param code - The code of the locality to update
+     * @param fields - The fields to update
+     * @returns A promise that resolves to the result of the update operation
+     */
+    updateByCode(code: string, fields: Partial<Locality>): Promise<import("mongodb").UpdateResult<Locality>>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const localities: LocalitiesClass;
+export {};

package/dist/src/interfaces/localities/localities.interface.js

@@ -0,0 +1,49 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+class LocalitiesClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!LocalitiesClass._instance) {
+            const instance = new LocalitiesClass();
+            await instance.connect();
+            LocalitiesClass._instance = instance;
+        }
+        return LocalitiesClass._instance;
+    }
+    /**
+     * Finds a locality by its code
+     *
+     * @param code - The code of the locality to find
+     * @returns A promise that resolves to the matching locality document or null if not found
+     */
+    async findByCode(code) {
+        return this.mongoCollection.findOne({ code });
+    }
+    /**
+     * Updates a locality by its code
+     *
+     * @param code - The code of the locality to update
+     * @param fields - The fields to update
+     * @returns A promise that resolves to the result of the update operation
+     */
+    async updateByCode(code, fields) {
+        return this.mongoCollection.updateOne({ code }, { $set: fields });
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { code: 1 }, unique: true },
+            { background: true, key: { name: 1 } },
+            { background: true, key: { prefix: 1 } },
+        ];
+    }
+    getCollectionName() {
+        return 'localities';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_LOCALITIES';
+    }
+}
+export const localities = AsyncSingletonProxy(LocalitiesClass);

package/dist/src/interfaces/municipalities/municipalities.interface.d.ts

@@ -0,0 +1,28 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateMunicipalityDto, Municipality, UpdateMunicipalityDto } from '@tmlmobilidade/types';
+import { IndexDescription } from 'mongodb';
+declare class MunicipalitiesClass extends MongoCollectionClass<Municipality, CreateMunicipalityDto, UpdateMunicipalityDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<MunicipalitiesClass>;
+    /**
+     * Finds a municipality by its code
+     *
+     * @param code - The code of the municipality to find
+     * @returns A promise that resolves to the matching municipality document or null if not found
+     */
+    findByCode(code: string): Promise<import("mongodb").WithId<Municipality> | null>;
+    /**
+     * Updates a municipality by its code
+     *
+     * @param code - The code of the municipality to update
+     * @param fields - The fields to update
+     * @returns A promise that resolves to the result of the update operation
+     */
+    updateByCode(code: string, fields: Partial<Municipality>): Promise<import("mongodb").UpdateResult<Municipality>>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const municipalities: MunicipalitiesClass;
+export {};

package/dist/src/interfaces/municipalities/municipalities.interface.js

@@ -0,0 +1,49 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+class MunicipalitiesClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!MunicipalitiesClass._instance) {
+            const instance = new MunicipalitiesClass();
+            await instance.connect();
+            MunicipalitiesClass._instance = instance;
+        }
+        return MunicipalitiesClass._instance;
+    }
+    /**
+     * Finds a municipality by its code
+     *
+     * @param code - The code of the municipality to find
+     * @returns A promise that resolves to the matching municipality document or null if not found
+     */
+    async findByCode(code) {
+        return this.mongoCollection.findOne({ code });
+    }
+    /**
+     * Updates a municipality by its code
+     *
+     * @param code - The code of the municipality to update
+     * @param fields - The fields to update
+     * @returns A promise that resolves to the result of the update operation
+     */
+    async updateByCode(code, fields) {
+        return this.mongoCollection.updateOne({ code }, { $set: fields });
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { code: 1 }, unique: true },
+            { background: true, key: { name: 1 } },
+            { background: true, key: { prefix: 1 } },
+        ];
+    }
+    getCollectionName() {
+        return 'municipalities';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_MUNICIPALITIES';
+    }
+}
+export const municipalities = AsyncSingletonProxy(MunicipalitiesClass);

package/dist/src/interfaces/organizations/organizations.interface.d.ts

@@ -0,0 +1,52 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateOrganizationDto, Organization, UpdateOrganizationDto } from '@tmlmobilidade/types';
+import { IndexDescription, UpdateResult } from 'mongodb';
+declare class OrganizationsClass extends MongoCollectionClass<Organization, CreateOrganizationDto, UpdateOrganizationDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<OrganizationsClass>;
+    /**
+     * Finds an organization by its code
+     *
+     * @param code - The code of the organization to find
+     * @returns A promise that resolves to the matching organization document or null if not found
+     */
+    findByCode(code: string): Promise<import("mongodb").WithId<{
+        _id: string;
+        code: string;
+        name: string;
+        created_at?: (number & {
+            __brand: "UnixTimestamp";
+        } & import("zod").BRAND<"UnixTimestamp">) | null | undefined;
+        updated_at?: (number & {
+            __brand: "UnixTimestamp";
+        } & import("zod").BRAND<"UnixTimestamp">) | null | undefined;
+    }> | null>;
+    /**
+     * Updates an organization by its code
+     *
+     * @param code - The code of the organization to update
+     * @param fields - The fields to update
+     * @returns A promise that resolves to the result of the update operation
+     */
+    updateByCode(code: string, fields: Partial<Organization>): Promise<UpdateResult<{
+        _id: string;
+        code: string;
+        name: string;
+        created_at?: (number & {
+            __brand: "UnixTimestamp";
+        } & import("zod").BRAND<"UnixTimestamp">) | null | undefined;
+        updated_at?: (number & {
+            __brand: "UnixTimestamp";
+        } & import("zod").BRAND<"UnixTimestamp">) | null | undefined;
+    }>>;
+    /**
+     * Disable Update Many
+     */
+    updateMany(): Promise<UpdateResult<Organization>>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const organizations: OrganizationsClass;
+export {};

package/dist/src/interfaces/organizations/organizations.interface.js

@@ -0,0 +1,54 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { HttpException, HttpStatus } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+class OrganizationsClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!OrganizationsClass._instance) {
+            const instance = new OrganizationsClass();
+            await instance.connect();
+            OrganizationsClass._instance = instance;
+        }
+        return OrganizationsClass._instance;
+    }
+    /**
+     * Finds an organization by its code
+     *
+     * @param code - The code of the organization to find
+     * @returns A promise that resolves to the matching organization document or null if not found
+     */
+    async findByCode(code) {
+        return this.mongoCollection.findOne({ code });
+    }
+    /**
+     * Updates an organization by its code
+     *
+     * @param code - The code of the organization to update
+     * @param fields - The fields to update
+     * @returns A promise that resolves to the result of the update operation
+     */
+    async updateByCode(code, fields) {
+        return this.mongoCollection.updateOne({ code }, { $set: fields });
+    }
+    /**
+     * Disable Update Many
+     */
+    async updateMany() {
+        throw new HttpException(HttpStatus.METHOD_NOT_ALLOWED, 'Method not allowed for organizations');
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { name: 1 }, unique: true },
+        ];
+    }
+    getCollectionName() {
+        return 'organizations';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_ORGANIZATIONS';
+    }
+}
+export const organizations = AsyncSingletonProxy(OrganizationsClass);

package/dist/src/interfaces/plans/plans.interface.d.ts

@@ -0,0 +1,20 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreatePlanDto, Plan, UpdatePlanDto } from '@tmlmobilidade/types';
+import { IndexDescription } from 'mongodb';
+declare class PlansClass extends MongoCollectionClass<Plan, CreatePlanDto, UpdatePlanDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<PlansClass>;
+    /**
+     * Finds Plan documents by agency ID.
+     *
+     * @param id - The agency ID to search for
+     * @returns A promise that resolves to an array of matching documents
+     */
+    findByAgencyId(id: string): Promise<import("mongodb").WithId<Plan>[]>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const plans: PlansClass;
+export {};