@tmlmobilidade/interfaces 20250325.1729.19

package/README.md

@@ -0,0 +1,33 @@
+## @tmlmobilidade/interfaces
+
+This package provides SDK-style connectors for interacting with databases (e.g., stops, plans, rides, alerts) and external providers (e.g., authentication, storage).
+It simplifies data access and integration across projects.
+
+### Purpose
+- Unified interface for accessing databases and external services
+- Reduces boilerplate by handling common queries and operations
+- Ensures consistency across different modules
+
+### Installation
+```
+npm install @tmlmobilidade/interfaces
+```
+
+### Local development
+
+Each interface has a given fixed port number to connect to the corresponding database instance. Use these
+
+| Interface Name | Port  | Env Value                           |
+|----------------|:-----:|-------------------------------------|
+| auth           | 37000 | mongodb://root:root@localhost:37000 |
+| files          | 37001 | mongodb://root:root@localhost:37001 |
+| stops          | 37002 | mongodb://root:root@localhost:37002 |
+| agencies       | 37003 | mongodb://root:root@localhost:37003 |
+| plans          | 37004 | mongodb://root:root@localhost:37004 |
+| alerts         | 37005 | mongodb://root:root@localhost:37005 |
+| rides          | 37006 | mongodb://root:root@localhost:37006 |
+| vehicle_events | 37007 | mongodb://root:root@localhost:37007 |
+| hashed_shapes  | 37008 | mongodb://root:root@localhost:37008 |
+| hashed_trips   | 37009 | mongodb://root:root@localhost:37009 |
+| apex_t11       | 37010 | mongodb://root:root@localhost:37010 |
+| apex_t19       | 37011 | mongodb://root:root@localhost:37011 |

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/interfaces/index.js';
+export * from './src/providers/index.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+/* * */
+export * from './src/interfaces/index.js';
+export * from './src/providers/index.js';

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

@@ -0,0 +1,18 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { Agency, CreateAgencyDto, UpdateAgencyDto } from '@tmlmobilidade/types';
+import { IndexDescription } from 'mongodb';
+import { z } from 'zod';
+declare class AgenciesClass extends MongoCollectionClass<Agency, CreateAgencyDto, UpdateAgencyDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<AgenciesClass>;
+    findByCode(code: string): Promise<import("mongodb").WithId<Agency> | null>;
+    updateByCode(code: string, fields: Partial<Agency>): Promise<import("mongodb").UpdateResult<Agency>>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getCreateSchema(): z.ZodSchema;
+    protected getEnvName(): string;
+    protected getUpdateSchema(): z.ZodSchema;
+}
+export declare const agencies: AgenciesClass;
+export {};

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

@@ -0,0 +1,46 @@
+/* * */
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AgencySchema, UpdateAgencySchema } from '@tmlmobilidade/types';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+/* * */
+class AgenciesClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!AgenciesClass._instance) {
+            const instance = new AgenciesClass();
+            await instance.connect();
+            AgenciesClass._instance = instance;
+        }
+        return AgenciesClass._instance;
+    }
+    async findByCode(code) {
+        return this.mongoCollection.findOne({ code });
+    }
+    async updateByCode(code, fields) {
+        return this.mongoCollection.updateOne({ code }, { $set: fields });
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { name: 1 }, unique: true },
+            { background: true, key: { code: 1 }, unique: true },
+            { background: true, key: { email: 1 }, unique: true },
+        ];
+    }
+    getCollectionName() {
+        return 'agencies';
+    }
+    getCreateSchema() {
+        return AgencySchema;
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_AGENCIES';
+    }
+    getUpdateSchema() {
+        return UpdateAgencySchema;
+    }
+}
+/* * */
+export const agencies = AsyncSingletonProxy(AgenciesClass);

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

@@ -0,0 +1,15 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { Alert, CreateAlertDto, UpdateAlertDto } from '@tmlmobilidade/types';
+import { IndexDescription } from 'mongodb';
+declare class AlertsClass extends MongoCollectionClass<Alert, CreateAlertDto, UpdateAlertDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<AlertsClass>;
+    findByMunicipalityId(municipality_id: string): Promise<import("mongodb").WithId<Alert>[]>;
+    findByTitle(title: string): Promise<import("mongodb").WithId<Alert> | null>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const alerts: AlertsClass;
+export {};

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

@@ -0,0 +1,44 @@
+/* * */
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+/* * */
+class AlertsClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!AlertsClass._instance) {
+            const instance = new AlertsClass();
+            await instance.connect();
+            AlertsClass._instance = instance;
+        }
+        return AlertsClass._instance;
+    }
+    async findByMunicipalityId(municipality_id) {
+        return this.mongoCollection.find({ municipality_ids: { $in: [municipality_id] } }).toArray();
+    }
+    async findByTitle(title) {
+        return this.mongoCollection.findOne({ title });
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { agency_ids: 1 } },
+            { background: true, key: { line_ids: 1 } },
+            { background: true, key: { municipality_ids: 1 } },
+            { background: true, key: { route_ids: 1 } },
+            { background: true, key: { stop_ids: 1 } },
+            { background: true, key: { title: 1 } },
+            { background: true, key: { active_period_end_date: -1, active_period_start_date: -1 } },
+            { background: true, key: { publish_end_date: -1, publish_start_date: -1 } },
+        ];
+    }
+    getCollectionName() {
+        return 'alerts';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_ALERTS';
+    }
+}
+/* * */
+export const alerts = AsyncSingletonProxy(AlertsClass);

package/dist/src/interfaces/apex-t11/apex-t11.interface.d.ts

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

package/dist/src/interfaces/apex-t11/apex-t11.interface.js

@@ -0,0 +1,37 @@
+/* * */
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+/* * */
+class ApexT11Class extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!ApexT11Class._instance) {
+            const instance = new ApexT11Class();
+            await instance.connect();
+            ApexT11Class._instance = instance;
+        }
+        return ApexT11Class._instance;
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { created_at: 1 } },
+            { background: true, key: { received_at: 1 } },
+            { background: true, key: { card_serial_number: 1 } },
+            { background: true, key: { agency_id: 1 } },
+            // eslint-disable-next-line perfectionist/sort-objects
+            { background: true, key: { trip_id: 1, created_at: 1 } },
+            { background: true, key: { agency_id: 1, created_at: 1 } },
+        ];
+    }
+    getCollectionName() {
+        return 'apex_t11';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_APEX_T11';
+    }
+}
+/* * */
+export const apexT11 = AsyncSingletonProxy(ApexT11Class);

package/dist/src/interfaces/apex-t19/apex-t19.interface.d.ts

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

package/dist/src/interfaces/apex-t19/apex-t19.interface.js

@@ -0,0 +1,36 @@
+/* * */
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+/* * */
+class ApexT19Class extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!ApexT19Class._instance) {
+            const instance = new ApexT19Class();
+            await instance.connect();
+            ApexT19Class._instance = instance;
+        }
+        return ApexT19Class._instance;
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { created_at: 1 } },
+            { background: true, key: { received_at: 1 } },
+            { background: true, key: { agency_id: 1 } },
+            // eslint-disable-next-line perfectionist/sort-objects
+            { background: true, key: { trip_id: 1, created_at: 1 } },
+            { background: true, key: { agency_id: 1, created_at: 1 } },
+        ];
+    }
+    getCollectionName() {
+        return 'apex_t19';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_APEX_T19';
+    }
+}
+/* * */
+export const apexT19 = AsyncSingletonProxy(ApexT19Class);

package/dist/src/interfaces/auth/roles.interface.d.ts

@@ -0,0 +1,24 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateRoleDto, Role, UpdateRoleDto } from '@tmlmobilidade/types';
+import { IndexDescription, UpdateResult } from 'mongodb';
+declare class RolesClass extends MongoCollectionClass<Role, CreateRoleDto, UpdateRoleDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<RolesClass>;
+    /**
+     * Finds a role by its name
+     *
+     * @param name - The name of the role to find
+     * @returns A promise that resolves to the matching role document or null if not found
+     */
+    findByName(name: string): Promise<import("mongodb").WithId<Role> | null>;
+    /**
+     * Disable Update Many
+     */
+    updateMany(): Promise<UpdateResult<Role>>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const roles: RolesClass;
+export {};

package/dist/src/interfaces/auth/roles.interface.js

@@ -0,0 +1,44 @@
+import { HttpException, HttpStatus } from '@tmlmobilidade/lib';
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+class RolesClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!RolesClass._instance) {
+            const instance = new RolesClass();
+            await instance.connect();
+            RolesClass._instance = instance;
+        }
+        return RolesClass._instance;
+    }
+    /**
+     * Finds a role by its name
+     *
+     * @param name - The name of the role to find
+     * @returns A promise that resolves to the matching role document or null if not found
+     */
+    async findByName(name) {
+        return this.mongoCollection.findOne({ name });
+    }
+    /**
+     * Disable Update Many
+     */
+    async updateMany() {
+        throw new HttpException(HttpStatus.METHOD_NOT_ALLOWED, 'Method not allowed for roles');
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { name: 1 }, unique: true },
+        ];
+    }
+    getCollectionName() {
+        return 'roles';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_AUTH';
+    }
+}
+export const roles = AsyncSingletonProxy(RolesClass);

package/dist/src/interfaces/auth/sessions.interface.d.ts

@@ -0,0 +1,17 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateSessionDto, Session, UpdateSessionDto } from '@tmlmobilidade/types';
+import { IndexDescription, UpdateResult } from 'mongodb';
+declare class SessionsClass extends MongoCollectionClass<Session, CreateSessionDto, UpdateSessionDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<SessionsClass>;
+    /**
+     * Disable Update Many
+     */
+    updateMany(): Promise<UpdateResult<Session>>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const sessions: SessionsClass;
+export {};

package/dist/src/interfaces/auth/sessions.interface.js

@@ -0,0 +1,37 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { HttpException, HttpStatus } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+class SessionsClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!SessionsClass._instance) {
+            const instance = new SessionsClass();
+            await instance.connect();
+            SessionsClass._instance = instance;
+        }
+        return SessionsClass._instance;
+    }
+    /**
+     * Disable Update Many
+     */
+    async updateMany() {
+        throw new HttpException(HttpStatus.METHOD_NOT_ALLOWED, 'Method not allowed for sessions');
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { user_id: 1 } },
+            { background: true, key: { expires: 1 } },
+            { background: true, key: { token: 1 }, unique: true },
+        ];
+    }
+    getCollectionName() {
+        return 'sessions';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_AUTH';
+    }
+}
+export const sessions = AsyncSingletonProxy(SessionsClass);

package/dist/src/interfaces/auth/users.interface.d.ts

@@ -0,0 +1,97 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateUserDto, UpdateUserDto, User } from '@tmlmobilidade/types';
+import { Filter, IndexDescription, Sort, WithId } from 'mongodb';
+type NewType = string;
+declare class UsersClass extends MongoCollectionClass<User, CreateUserDto, UpdateUserDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<UsersClass>;
+    /**
+     * Finds a user document by its email.
+     *
+     * @param email - The email of the user to find
+     * @param includePasswordHash - Whether to include the password hash in the result
+     * @returns A promise that resolves to the matching user document or null if not found
+     */
+    findByEmail(email: string, includePasswordHash?: boolean): Promise<null | WithId<User>>;
+    /**
+     * Finds a document by its ID.
+     *
+     * @param id - The ID of the document to find
+     * @param includePasswordHash - Whether to include the password hash in the result
+     * @returns A promise that resolves to the matching document or null if not found
+     */
+    findById(id: string, includePasswordHash?: boolean): Promise<WithId<User> | null>;
+    /**
+     * Finds users by their organization code
+     *
+     * @param code - The code of the organization to find users for
+     * @param includePasswordHash - Whether to include the password hash in the result
+     * @returns A promise that resolves to the matching user documents or null if not found
+     */
+    findByOrganization(id: NewType, includePasswordHash?: boolean): Promise<{
+        created_at: import("@tmlmobilidade/types").UnixTimestamp;
+        updated_at: import("@tmlmobilidade/types").UnixTimestamp;
+        email: string;
+        phone?: string | null | undefined | undefined;
+        permissions: {
+            action: string;
+            scope: string;
+            resource?: Record<string, any> | null | undefined;
+        }[];
+        email_verified?: (null | import("@tmlmobilidade/types").UnixTimestamp) | undefined;
+        first_name: string;
+        last_name: string;
+        organization_ids: string[];
+        role_ids: string[];
+        session_ids: string[];
+        verification_token_ids: string[];
+        avatar?: string | null | undefined | undefined;
+        bio?: string | null | undefined | undefined;
+        _id: string;
+    }[]>;
+    /**
+     * Finds a user by their role
+     *
+     * @param role - The role of the user to find
+     * @returns A promise that resolves to the matching user document or null if not found
+     */
+    findByRole(role: string, includePasswordHash?: boolean): Promise<{
+        created_at: import("@tmlmobilidade/types").UnixTimestamp;
+        updated_at: import("@tmlmobilidade/types").UnixTimestamp;
+        email: string;
+        phone?: string | null | undefined | undefined;
+        permissions: {
+            action: string;
+            scope: string;
+            resource?: Record<string, any> | null | undefined;
+        }[];
+        email_verified?: (null | import("@tmlmobilidade/types").UnixTimestamp) | undefined;
+        first_name: string;
+        last_name: string;
+        organization_ids: string[];
+        role_ids: string[];
+        session_ids: string[];
+        verification_token_ids: string[];
+        avatar?: string | null | undefined | undefined;
+        bio?: string | null | undefined | undefined;
+        _id: string;
+    }[]>;
+    /**
+     * Finds multiple documents matching the filter criteria with optional pagination and sorting.
+     *
+     * @param filter - (Optional) filter criteria to match documents
+     * @param perPage - (Optional) number of documents per page for pagination
+     * @param page - (Optional) page number for pagination
+     * @param sort - (Optional) sort specification
+     * @returns A promise that resolves to an array of matching documents
+     */
+    findMany(filter?: Filter<User>, perPage?: number, page?: number, sort?: Sort): Promise<WithId<User>[]>;
+    findOne(filter: Filter<User>): Promise<WithId<User> | null>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+    private deletePasswordHash;
+}
+export declare const users: UsersClass;
+export {};

package/dist/src/interfaces/auth/users.interface.js

@@ -0,0 +1,112 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+class UsersClass extends MongoCollectionClass {
+    static _instance;
+    constructor() {
+        super();
+    }
+    static async getInstance() {
+        if (!UsersClass._instance) {
+            const instance = new UsersClass();
+            await instance.connect();
+            UsersClass._instance = instance;
+        }
+        return UsersClass._instance;
+    }
+    /**
+     * Finds a user document by its email.
+     *
+     * @param email - The email of the user to find
+     * @param includePasswordHash - Whether to include the password hash in the result
+     * @returns A promise that resolves to the matching user document or null if not found
+     */
+    async findByEmail(email, includePasswordHash = false) {
+        const user = await this.mongoCollection.findOne({ email });
+        if (!user) {
+            return null;
+        }
+        return includePasswordHash ? user : this.deletePasswordHash(user);
+    }
+    /**
+     * Finds a document by its ID.
+     *
+     * @param id - The ID of the document to find
+     * @param includePasswordHash - Whether to include the password hash in the result
+     * @returns A promise that resolves to the matching document or null if not found
+     */
+    async findById(id, includePasswordHash = false) {
+        const user = await this.mongoCollection.findOne({ _id: id });
+        if (!user) {
+            return null;
+        }
+        return includePasswordHash ? user : this.deletePasswordHash(user);
+    }
+    /**
+     * Finds users by their organization code
+     *
+     * @param code - The code of the organization to find users for
+     * @param includePasswordHash - Whether to include the password hash in the result
+     * @returns A promise that resolves to the matching user documents or null if not found
+     */
+    async findByOrganization(id, includePasswordHash = false) {
+        const users = await this.mongoCollection.find({ organization_ids: { $in: [id] } }).toArray();
+        return includePasswordHash ? users : users.map(user => this.deletePasswordHash(user));
+    }
+    /**
+     * Finds a user by their role
+     *
+     * @param role - The role of the user to find
+     * @returns A promise that resolves to the matching user document or null if not found
+     */
+    async findByRole(role, includePasswordHash = false) {
+        const users = await this.mongoCollection.find({ role_ids: { $in: [role] } }).toArray();
+        return includePasswordHash ? users : users.map(user => this.deletePasswordHash(user));
+    }
+    /**
+     * Finds multiple documents matching the filter criteria with optional pagination and sorting.
+     *
+     * @param filter - (Optional) filter criteria to match documents
+     * @param perPage - (Optional) number of documents per page for pagination
+     * @param page - (Optional) page number for pagination
+     * @param sort - (Optional) sort specification
+     * @returns A promise that resolves to an array of matching documents
+     */
+    async findMany(filter, perPage, page, sort) {
+        const query = this.mongoCollection.find(filter ?? {});
+        if (perPage)
+            query.limit(perPage);
+        if (page && perPage)
+            query.skip(perPage * (page - 1));
+        if (sort)
+            query.sort(sort);
+        const users = await query.toArray();
+        return users.map(user => this.deletePasswordHash(user));
+    }
+    async findOne(filter) {
+        const user = await this.mongoCollection.findOne(filter);
+        if (!user) {
+            return null;
+        }
+        return this.deletePasswordHash(user);
+    }
+    getCollectionIndexes() {
+        return [
+            { background: true, key: { email: 1 }, unique: true },
+            { background: true, key: { 'profile.first_name': 1, 'profile.last_name': 1 } },
+            { background: true, key: { session_ids: 1 } },
+            { background: true, key: { role_ids: 1 } },
+        ];
+    }
+    getCollectionName() {
+        return 'users';
+    }
+    getEnvName() {
+        return 'TML_INTERFACE_AUTH';
+    }
+    deletePasswordHash(user) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { password_hash, ...userWithoutPassword } = user;
+        return userWithoutPassword;
+    }
+}
+export const users = AsyncSingletonProxy(UsersClass);

package/dist/src/interfaces/auth/verification-tokens.interface.d.ts

@@ -0,0 +1,24 @@
+import { MongoCollectionClass } from '@tmlmobilidade/lib';
+import { CreateVerificationTokenDto, UpdateVerificationTokenDto, VerificationToken } from '@tmlmobilidade/types';
+import { IndexDescription, UpdateResult } from 'mongodb';
+declare class VerificationTokensClass extends MongoCollectionClass<VerificationToken, CreateVerificationTokenDto, UpdateVerificationTokenDto> {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<VerificationTokensClass>;
+    /**
+     * Finds a verification token by its token.
+     *
+     * @param token - The token to find
+     * @returns The verification token or null if not found
+     */
+    findByToken(token: string): Promise<import("mongodb").WithId<VerificationToken> | null>;
+    /**
+     * Disable Update Many
+     */
+    updateMany(): Promise<UpdateResult<VerificationToken>>;
+    protected getCollectionIndexes(): IndexDescription[];
+    protected getCollectionName(): string;
+    protected getEnvName(): string;
+}
+export declare const verificationTokens: VerificationTokensClass;
+export {};