@aeriajs/types 0.0.114 → 0.0.116

package/dist/accessControl.d.ts

@@ -1,17 +1,17 @@
 import type { UserRole } from './token.js';
 export type AccessCondition = undefined | boolean | readonly UserRole[] | 'unauthenticated' | 'unauthenticated-only';
 export type RoleFromAccessCondition<TAccessCondition extends AccessCondition | undefined> = undefined extends TAccessCondition ? null : TAccessCondition extends readonly (infer Role)[] ? Role : TAccessCondition extends true ? Exclude<UserRole, 'unauthenticated'> : TAccessCondition extends false ? never : TAccessCondition extends 'unauthenticated-only' ? 'unauthenticated' : TAccessCondition extends 'unauthenticated' ? UserRole : never;
-export declare enum ACError {
-    AuthenticationError = "AUTHENTICATION_ERROR",
-    AuthorizationError = "AUTHORIZATION_ERROR",
-    FunctionNotFound = "FUNCTION_NOT_FOUND",
-    FunctionNotExposed = "FUNCTION_NOT_EXPOSED",
-    TargetImmutable = "TARGET_IMMUTABLE",
-    InvalidLimit = "INVALID_LIMIT",
-    OwnershipError = "OWNERSHIP_ERROR",
-    ResourceNotFound = "RESOURCE_NOT_FOUND",
-    InsecureOperator = "INSECURE_OPERATOR",
-    MalformedInput = "MALFORMED_INPUT",
-    UniquenessViolated = "UNIQUENESS_VIOLATED",
-    UnknownError = "UNKNOWN_ERROR"
-}
+export declare const ACError: {
+    readonly AuthenticationError: "AUTHENTICATION_ERROR";
+    readonly AuthorizationError: "AUTHORIZATION_ERROR";
+    readonly FunctionNotFound: "FUNCTION_NOT_FOUND";
+    readonly FunctionNotExposed: "FUNCTION_NOT_EXPOSED";
+    readonly TargetImmutable: "TARGET_IMMUTABLE";
+    readonly InvalidLimit: "INVALID_LIMIT";
+    readonly OwnershipError: "OWNERSHIP_ERROR";
+    readonly ResourceNotFound: "RESOURCE_NOT_FOUND";
+    readonly InsecureOperator: "INSECURE_OPERATOR";
+    readonly MalformedInput: "MALFORMED_INPUT";
+    readonly UniquenessViolated: "UNIQUENESS_VIOLATED";
+    readonly UnknownError: "UNKNOWN_ERROR";
+};

package/dist/accessControl.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ACError = void 0;
-var ACError;
-(function (ACError) {
-    ACError["AuthenticationError"] = "AUTHENTICATION_ERROR";
-    ACError["AuthorizationError"] = "AUTHORIZATION_ERROR";
-    ACError["FunctionNotFound"] = "FUNCTION_NOT_FOUND";
-    ACError["FunctionNotExposed"] = "FUNCTION_NOT_EXPOSED";
-    ACError["TargetImmutable"] = "TARGET_IMMUTABLE";
-    ACError["InvalidLimit"] = "INVALID_LIMIT";
-    ACError["OwnershipError"] = "OWNERSHIP_ERROR";
-    ACError["ResourceNotFound"] = "RESOURCE_NOT_FOUND";
-    ACError["InsecureOperator"] = "INSECURE_OPERATOR";
-    ACError["MalformedInput"] = "MALFORMED_INPUT";
-    ACError["UniquenessViolated"] = "UNIQUENESS_VIOLATED";
-    ACError["UnknownError"] = "UNKNOWN_ERROR";
-})(ACError || (exports.ACError = ACError = {}));
+exports.ACError = {
+    AuthenticationError: 'AUTHENTICATION_ERROR',
+    AuthorizationError: 'AUTHORIZATION_ERROR',
+    FunctionNotFound: 'FUNCTION_NOT_FOUND',
+    FunctionNotExposed: 'FUNCTION_NOT_EXPOSED',
+    TargetImmutable: 'TARGET_IMMUTABLE',
+    InvalidLimit: 'INVALID_LIMIT',
+    OwnershipError: 'OWNERSHIP_ERROR',
+    ResourceNotFound: 'RESOURCE_NOT_FOUND',
+    InsecureOperator: 'INSECURE_OPERATOR',
+    MalformedInput: 'MALFORMED_INPUT',
+    UniquenessViolated: 'UNIQUENESS_VIOLATED',
+    UnknownError: 'UNKNOWN_ERROR',
+};

package/dist/accessControl.mjs

@@ -1,16 +1,15 @@
 "use strict";
-export var ACError = /* @__PURE__ */ ((ACError2) => {
-  ACError2["AuthenticationError"] = "AUTHENTICATION_ERROR";
-  ACError2["AuthorizationError"] = "AUTHORIZATION_ERROR";
-  ACError2["FunctionNotFound"] = "FUNCTION_NOT_FOUND";
-  ACError2["FunctionNotExposed"] = "FUNCTION_NOT_EXPOSED";
-  ACError2["TargetImmutable"] = "TARGET_IMMUTABLE";
-  ACError2["InvalidLimit"] = "INVALID_LIMIT";
-  ACError2["OwnershipError"] = "OWNERSHIP_ERROR";
-  ACError2["ResourceNotFound"] = "RESOURCE_NOT_FOUND";
-  ACError2["InsecureOperator"] = "INSECURE_OPERATOR";
-  ACError2["MalformedInput"] = "MALFORMED_INPUT";
-  ACError2["UniquenessViolated"] = "UNIQUENESS_VIOLATED";
-  ACError2["UnknownError"] = "UNKNOWN_ERROR";
-  return ACError2;
-})(ACError || {});
+export const ACError = {
+  AuthenticationError: "AUTHENTICATION_ERROR",
+  AuthorizationError: "AUTHORIZATION_ERROR",
+  FunctionNotFound: "FUNCTION_NOT_FOUND",
+  FunctionNotExposed: "FUNCTION_NOT_EXPOSED",
+  TargetImmutable: "TARGET_IMMUTABLE",
+  InvalidLimit: "INVALID_LIMIT",
+  OwnershipError: "OWNERSHIP_ERROR",
+  ResourceNotFound: "RESOURCE_NOT_FOUND",
+  InsecureOperator: "INSECURE_OPERATOR",
+  MalformedInput: "MALFORMED_INPUT",
+  UniquenessViolated: "UNIQUENESS_VIOLATED",
+  UnknownError: "UNKNOWN_ERROR"
+};

package/dist/config.d.ts

@@ -4,16 +4,20 @@ import type { RateLimitingParams } from './security.js';
 import type { CollectionItem } from './collection.js';
 import type { UserRole } from './token.js';
 export type RolesHierarchy = Record<UserRole, readonly UserRole[] | boolean>;
+export type ServerOptions = {
+    host?: string;
+    port?: number;
+    enableLogging?: boolean;
+};
 export type ApiConfig = {
     name?: string;
     secret?: string;
     baseUrl?: RouteUri;
     publicUrl?: string;
     webPublicUrl?: string;
-    host?: string;
-    port?: number;
     defaultPaginationLimit?: number;
     noWarmup?: boolean;
+    server?: ServerOptions;
     database?: {
         mongodbUrl?: string;
         noDatabase?: boolean;

package/dist/context.d.ts

@@ -44,10 +44,10 @@ export type RouteContext<TAccessCondition extends AccessCondition = false> = {
     request: GenericRequest;
     response: GenericResponse;
     log: (message: string, details?: unknown) => Promise<unknown>;
-    error: <const THTTPStatus extends HTTPStatus, const TEndpointError extends Omit<EndpointError, 'httpStatus'>>(httpStatus: THTTPStatus, error: TEndpointError) => Result.Error<TEndpointError & {
+    error: <const THTTPStatus extends typeof HTTPStatus[keyof typeof HTTPStatus], const TEndpointError extends Omit<EndpointError, 'httpStatus'>>(httpStatus: THTTPStatus, error: TEndpointError) => Result.Error<TEndpointError & {
         httpStatus: THTTPStatus;
     }>;
-    limitRate: (params: RateLimitingParams) => Promise<Result.Either<EndpointError<RateLimitingError, HTTPStatus.TooManyRequests>, {
+    limitRate: (params: RateLimitingParams) => Promise<Result.Either<EndpointError<typeof RateLimitingError[keyof typeof RateLimitingError], typeof HTTPStatus.TooManyRequests>, {
         hits: number;
         points: number;
         last_reach: Date;

package/dist/endpointError.d.ts

@@ -1,7 +1,7 @@
 import type { HTTPStatus } from './http.js';
 export declare const ERROR_SYMBOL_DESCRIPTION = "#__ERROR_SYMBOL__";
 export declare const ERROR_SYMBOL: unique symbol;
-export type EndpointError<TCode extends string = string, TDetails = unknown, THTTPStatus extends HTTPStatus | undefined = HTTPStatus, TMessage extends string | undefined = string> = {
+export type EndpointError<TCode extends string = string, TDetails = unknown, THTTPStatus extends typeof HTTPStatus[keyof typeof HTTPStatus] | undefined = typeof HTTPStatus[keyof typeof HTTPStatus], TMessage extends string | undefined = string> = {
     code: TCode;
     details?: TDetails;
     httpStatus: THTTPStatus;

package/dist/functionSchemas.d.ts

@@ -1,6 +1,3 @@
-import { ACError } from './accessControl.js';
-import { HTTPStatus } from './http.js';
-import { ValidationErrorCode, TraverseError } from './validation.js';
 export declare const insertError: () => {
     readonly type: "object";
     readonly properties: {
@@ -15,10 +12,10 @@ export declare const insertError: () => {
             readonly required: readonly ["httpStatus", "code"];
             readonly properties: {
                 readonly httpStatus: {
-                    readonly enum: [HTTPStatus.Forbidden, HTTPStatus.NotFound, HTTPStatus.UnprocessableContent, HTTPStatus.BadRequest, HTTPStatus.InternalServerError];
+                    readonly enum: [403, 404, 422, 400, 500];
                 };
                 readonly code: {
-                    readonly enum: [ACError.InsecureOperator, ACError.OwnershipError, ACError.ResourceNotFound, ACError.TargetImmutable, ACError.MalformedInput, ACError.UniquenessViolated, ValidationErrorCode.EmptyTarget, ValidationErrorCode.InvalidProperties, ValidationErrorCode.MissingProperties, TraverseError.InvalidDocumentId, TraverseError.InvalidTempfile];
+                    readonly enum: ["INSECURE_OPERATOR", "OWNERSHIP_ERROR", "RESOURCE_NOT_FOUND", "TARGET_IMMUTABLE", "MALFORMED_INPUT", "UNIQUENESS_VIOLATED", "EMPTY_TARGET", "INVALID_PROPERTIES", "MISSING_PROPERTIES", "INVALID_DOCUMENT_ID", "INVALID_TEMPFILE"];
                 };
                 readonly message: {
                     readonly type: "string";
@@ -45,10 +42,10 @@ export declare const getError: () => {
             readonly required: readonly ["httpStatus", "code"];
             readonly properties: {
                 readonly httpStatus: {
-                    readonly enum: [HTTPStatus.Forbidden, HTTPStatus.NotFound, HTTPStatus.BadRequest];
+                    readonly enum: [403, 404, 400];
                 };
                 readonly code: {
-                    readonly enum: [ACError.ResourceNotFound, ACError.OwnershipError, ACError.InsecureOperator, ACError.MalformedInput];
+                    readonly enum: ["RESOURCE_NOT_FOUND", "OWNERSHIP_ERROR", "INSECURE_OPERATOR", "MALFORMED_INPUT"];
                 };
                 readonly message: {
                     readonly type: "string";
@@ -75,10 +72,10 @@ export declare const getAllError: () => {
             readonly required: readonly ["httpStatus", "code"];
             readonly properties: {
                 readonly httpStatus: {
-                    readonly enum: [HTTPStatus.Forbidden];
+                    readonly enum: [403];
                 };
                 readonly code: {
-                    readonly enum: [ACError.OwnershipError, ACError.InsecureOperator, ACError.InvalidLimit];
+                    readonly enum: ["OWNERSHIP_ERROR", "INSECURE_OPERATOR", "INVALID_LIMIT"];
                 };
                 readonly message: {
                     readonly type: "string";
@@ -105,10 +102,10 @@ export declare const countError: () => {
             readonly required: readonly ["httpStatus", "code"];
             readonly properties: {
                 readonly httpStatus: {
-                    readonly enum: [HTTPStatus.Forbidden];
+                    readonly enum: [403];
                 };
                 readonly code: {
-                    readonly enum: [ACError.OwnershipError, ACError.InvalidLimit];
+                    readonly enum: ["OWNERSHIP_ERROR", "INVALID_LIMIT"];
                 };
                 readonly message: {
                     readonly type: "string";

package/dist/http.d.ts

@@ -4,18 +4,18 @@ import type { EndpointError } from './endpointError.js';
 import type { ACError } from './accessControl.js';
 import type { RateLimitingError } from './security.js';
 export declare const REQUEST_METHODS: readonly ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "PATCH", "TRACE", "SEARCH"];
-export declare enum HTTPStatus {
-    Ok = 200,
-    NoContent = 204,
-    BadRequest = 400,
-    Unauthorized = 401,
-    Forbidden = 403,
-    NotFound = 404,
-    RangeNotSatisfiable = 416,
-    UnprocessableContent = 422,
-    TooManyRequests = 429,
-    InternalServerError = 500
-}
+export declare const HTTPStatus: {
+    readonly Ok: 200;
+    readonly NoContent: 204;
+    readonly BadRequest: 400;
+    readonly Unauthorized: 401;
+    readonly Forbidden: 403;
+    readonly NotFound: 404;
+    readonly RangeNotSatisfiable: 416;
+    readonly UnprocessableContent: 422;
+    readonly TooManyRequests: 429;
+    readonly InternalServerError: 500;
+};
 export type RouteUri = `/${string}`;
 export type RequestMethod = string;
 export type GenericRequest = Omit<IncomingMessage, 'url' | 'method'> & {
@@ -32,8 +32,8 @@ export type GenericResponse = ServerResponse & {
 };
 type ExtractCode<TRouteResponse> = TRouteResponse extends EndpointError<infer PCode> ? PCode : never;
 type ExtractHTTPStatus<TRouteResponse> = TRouteResponse extends EndpointError<string, unknown, infer PHTTPStatus> ? PHTTPStatus : never;
-export type NativeError = ACError.AuthenticationError | ACError.AuthorizationError | RateLimitingError.LimitReached | RateLimitingError.Unauthenticated;
-export type NativeHTTPErrorStatus = HTTPStatus.Unauthorized | HTTPStatus.TooManyRequests;
+export type NativeError = typeof ACError.AuthenticationError | typeof ACError.AuthorizationError | typeof RateLimitingError.LimitReached | typeof RateLimitingError.Unauthenticated;
+export type NativeHTTPErrorStatus = typeof HTTPStatus.Unauthorized | typeof HTTPStatus.TooManyRequests;
 export type WithACErrors<TRouteResponse> = TRouteResponse extends Result.Either<infer InferredError, unknown> ? Result.Either<ExtractError<TRouteResponse> | EndpointError<ExtractCode<InferredError> | NativeError, unknown, ExtractHTTPStatus<InferredError> | NativeHTTPErrorStatus>, ExtractResult<TRouteResponse>> : TRouteResponse | Result.Error<EndpointError<NativeError, unknown, NativeHTTPErrorStatus>>;
 export type EndpointFunction<TRouteMethod extends RequestMethod, TRouteResponse, TRoutePayload> = (TRoutePayload extends null ? <T = TRouteResponse>(payload?: unknown) => Promise<WithACErrors<T>> : TRoutePayload extends undefined ? <T = TRouteResponse>() => Promise<WithACErrors<T>> : <T = TRouteResponse>(payload: TRoutePayload) => Promise<WithACErrors<T>>) extends infer Function ? Record<TRouteMethod, Function> : never;
 export type MakeEndpoint<TRoute extends string, TRouteMethod extends RequestMethod, TRouteResponse = unknown, TRoutePayload = null> = TRoute extends `/${infer RouteTail}` ? MakeEndpoint<RouteTail, TRouteMethod, TRouteResponse, TRoutePayload> : TRoute extends `${infer Route}/${infer RouteTail}` ? Record<Route, MakeEndpoint<RouteTail, TRouteMethod, TRouteResponse, TRoutePayload>> : TRoute extends `(${string}` ? Record<string, EndpointFunction<TRouteMethod, TRouteResponse, TRoutePayload>> : Record<TRoute, EndpointFunction<TRouteMethod, TRouteResponse, TRoutePayload>>;

package/dist/http.js

@@ -12,17 +12,16 @@ exports.REQUEST_METHODS = [
     'TRACE',
     'SEARCH',
 ];
-var HTTPStatus;
-(function (HTTPStatus) {
-    HTTPStatus[HTTPStatus["Ok"] = 200] = "Ok";
-    HTTPStatus[HTTPStatus["NoContent"] = 204] = "NoContent";
-    HTTPStatus[HTTPStatus["BadRequest"] = 400] = "BadRequest";
-    HTTPStatus[HTTPStatus["Unauthorized"] = 401] = "Unauthorized";
-    HTTPStatus[HTTPStatus["Forbidden"] = 403] = "Forbidden";
-    HTTPStatus[HTTPStatus["NotFound"] = 404] = "NotFound";
-    HTTPStatus[HTTPStatus["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
-    HTTPStatus[HTTPStatus["UnprocessableContent"] = 422] = "UnprocessableContent";
-    HTTPStatus[HTTPStatus["TooManyRequests"] = 429] = "TooManyRequests";
-    HTTPStatus[HTTPStatus["InternalServerError"] = 500] = "InternalServerError";
-})(HTTPStatus || (exports.HTTPStatus = HTTPStatus = {}));
+exports.HTTPStatus = {
+    Ok: 200,
+    NoContent: 204,
+    BadRequest: 400,
+    Unauthorized: 401,
+    Forbidden: 403,
+    NotFound: 404,
+    RangeNotSatisfiable: 416,
+    UnprocessableContent: 422,
+    TooManyRequests: 429,
+    InternalServerError: 500,
+};
 exports.STREAMED_RESPONSE = Symbol('StreamedResponse');

package/dist/http.mjs

@@ -10,17 +10,16 @@ export const REQUEST_METHODS = [
   "TRACE",
   "SEARCH"
 ];
-export var HTTPStatus = /* @__PURE__ */ ((HTTPStatus2) => {
-  HTTPStatus2[HTTPStatus2["Ok"] = 200] = "Ok";
-  HTTPStatus2[HTTPStatus2["NoContent"] = 204] = "NoContent";
-  HTTPStatus2[HTTPStatus2["BadRequest"] = 400] = "BadRequest";
-  HTTPStatus2[HTTPStatus2["Unauthorized"] = 401] = "Unauthorized";
-  HTTPStatus2[HTTPStatus2["Forbidden"] = 403] = "Forbidden";
-  HTTPStatus2[HTTPStatus2["NotFound"] = 404] = "NotFound";
-  HTTPStatus2[HTTPStatus2["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
-  HTTPStatus2[HTTPStatus2["UnprocessableContent"] = 422] = "UnprocessableContent";
-  HTTPStatus2[HTTPStatus2["TooManyRequests"] = 429] = "TooManyRequests";
-  HTTPStatus2[HTTPStatus2["InternalServerError"] = 500] = "InternalServerError";
-  return HTTPStatus2;
-})(HTTPStatus || {});
+export const HTTPStatus = {
+  Ok: 200,
+  NoContent: 204,
+  BadRequest: 400,
+  Unauthorized: 401,
+  Forbidden: 403,
+  NotFound: 404,
+  RangeNotSatisfiable: 416,
+  UnprocessableContent: 422,
+  TooManyRequests: 429,
+  InternalServerError: 500
+};
 export const STREAMED_RESPONSE = Symbol("StreamedResponse");

package/dist/resultSchemas.d.ts

@@ -24,7 +24,7 @@ export declare const resultSchema: <const TResult extends Property>(result: TRes
         readonly result: Property;
     };
 };
-export declare const endpointErrorSchema: <const THTTPStatus extends HTTPStatus[], const TCode extends string[]>(error: {
+export declare const endpointErrorSchema: <const THTTPStatus extends (typeof HTTPStatus)[keyof typeof HTTPStatus][], const TCode extends string[]>(error: {
     httpStatus: THTTPStatus;
     code: TCode;
 }) => {

package/dist/security.d.ts

@@ -3,10 +3,10 @@ import type { What } from './functions.js';
 import type { Result } from './result.js';
 import type { QuerySort } from './functions.js';
 export type OwnershipMode = boolean | 'always' | 'on-write';
-export declare enum RateLimitingError {
-    Unauthenticated = "UNAUTHENTICATED",
-    LimitReached = "LIMIT_REACHED"
-}
+export declare const RateLimitingError: {
+    readonly Unauthenticated: "UNAUTHENTICATED";
+    readonly LimitReached: "LIMIT_REACHED";
+};
 export type DiscriminationStrategy = 'tenant' | 'ip';
 export type RateLimitingWithScale = {
     scale: number;

package/dist/security.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RateLimitingError = void 0;
-var RateLimitingError;
-(function (RateLimitingError) {
-    RateLimitingError["Unauthenticated"] = "UNAUTHENTICATED";
-    RateLimitingError["LimitReached"] = "LIMIT_REACHED";
-})(RateLimitingError || (exports.RateLimitingError = RateLimitingError = {}));
+exports.RateLimitingError = {
+    Unauthenticated: 'UNAUTHENTICATED',
+    LimitReached: 'LIMIT_REACHED',
+};

package/dist/security.mjs

@@ -1,6 +1,5 @@
 "use strict";
-export var RateLimitingError = /* @__PURE__ */ ((RateLimitingError2) => {
-  RateLimitingError2["Unauthenticated"] = "UNAUTHENTICATED";
-  RateLimitingError2["LimitReached"] = "LIMIT_REACHED";
-  return RateLimitingError2;
-})(RateLimitingError || {});
+export const RateLimitingError = {
+  Unauthenticated: "UNAUTHENTICATED",
+  LimitReached: "LIMIT_REACHED"
+};

package/dist/token.d.ts

@@ -1,15 +1,16 @@
 import type { ObjectId } from 'mongodb';
 import type { PackReferences } from './schema.js';
 import type { AccessCondition } from './accessControl.js';
+export type UserInfo = Omit<Collections['user']['item'], '_id' | 'roles'>;
 export type UserRole = (Collections['user']['item'] extends {
     roles: infer Roles;
 } ? Roles extends unknown[] ? Roles[number] extends infer UserDefinedRole ? UserDefinedRole extends string ? `${UserDefinedRole}${UserDefinedRole}` extends UserDefinedRole ? 'root' : UserDefinedRole : never : never : never : never) | 'root' | 'unauthenticated';
-export type AuthenticatedToken<TAccessCondition extends AccessCondition = true, TUserRole = UserRole, TUserInfo = Omit<Collections['user']['item'], '_id' | 'roles'>> = {
+export type AuthenticatedToken<TAccessCondition extends AccessCondition = true, TUserRole = UserRole> = {
     authenticated: true;
     sub: ObjectId | null;
     roles: TAccessCondition extends readonly unknown[] ? TAccessCondition : TAccessCondition extends true ? readonly TUserRole[] : TAccessCondition extends 'unauthenticated' ? readonly UserRole[] : readonly [];
     picture?: string;
-    userinfo: Partial<TUserInfo | PackReferences<TUserInfo>>;
+    userinfo: Partial<UserInfo | PackReferences<UserInfo>>;
 };
 export type UnauthenticatedToken = {
     authenticated: false;
@@ -19,4 +20,4 @@ export type TokenRecipient = {
     type: 'bearer';
     content: string;
 };
-export type Token<TAccessCondition extends AccessCondition = false, TUserRole = UserRole, TUserInfo = Omit<Collections['user']['item'], '_id' | 'roles'>> = (false extends TAccessCondition ? false : TAccessCondition extends 'unauthenticated' | 'unauthenticated-only' ? false : true) extends true ? AuthenticatedToken<TAccessCondition> : 'unauthenticated-only' extends TAccessCondition ? UnauthenticatedToken : AuthenticatedToken<true, TUserRole, TUserInfo> | UnauthenticatedToken;
+export type Token<TAccessCondition extends AccessCondition = false, TUserRole = UserRole> = (false extends TAccessCondition ? false : TAccessCondition extends 'unauthenticated' | 'unauthenticated-only' ? false : true) extends true ? AuthenticatedToken<TAccessCondition> : 'unauthenticated-only' extends TAccessCondition ? UnauthenticatedToken : AuthenticatedToken<true, TUserRole> | UnauthenticatedToken;

package/dist/validation.d.ts

@@ -1,24 +1,24 @@
-export declare enum ValidationErrorCode {
-    InvalidProperties = "INVALID_PROPERTIES",
-    MissingProperties = "MISSING_PROPERTIES",
-    EmptyTarget = "EMPTY_TARGET"
-}
-export declare enum PropertyValidationErrorCode {
-    Missing = "MISSING_PROPERTY",
-    Extraneous = "EXTRANEOUS_PROPERTY",
-    Unmatching = "UNMATCHING_PROPERTIES",
-    ExtraneousElement = "EXTRANEOUS_ELEMENT",
-    MoreItemsExpected = "MORE_ITEMS_EXPECTED",
-    LessItemsExpected = "LESS_ITEMS_EXPECTED",
-    NumericConstraint = "NUMERIC_CONSTRAINT",
-    StringConstraint = "STRING_CONSTRAINT"
-}
-export declare enum TraverseError {
-    InvalidDocumentId = "INVALID_DOCUMENT_ID",
-    InvalidTempfile = "INVALID_TEMPFILE"
-}
+export declare const ValidationErrorCode: {
+    readonly InvalidProperties: "INVALID_PROPERTIES";
+    readonly MissingProperties: "MISSING_PROPERTIES";
+    readonly EmptyTarget: "EMPTY_TARGET";
+};
+export declare const PropertyValidationErrorCode: {
+    readonly Missing: "MISSING_PROPERTY";
+    readonly Extraneous: "EXTRANEOUS_PROPERTY";
+    readonly Unmatching: "UNMATCHING_PROPERTIES";
+    readonly ExtraneousElement: "EXTRANEOUS_ELEMENT";
+    readonly MoreItemsExpected: "MORE_ITEMS_EXPECTED";
+    readonly LessItemsExpected: "LESS_ITEMS_EXPECTED";
+    readonly NumericConstraint: "NUMERIC_CONSTRAINT";
+    readonly StringConstraint: "STRING_CONSTRAINT";
+};
+export declare const TraverseError: {
+    readonly InvalidDocumentId: "INVALID_DOCUMENT_ID";
+    readonly InvalidTempfile: "INVALID_TEMPFILE";
+};
 export type PropertyValidationError = {
-    type: PropertyValidationErrorCode;
+    type: typeof PropertyValidationErrorCode[keyof typeof PropertyValidationErrorCode];
     index?: number;
     details?: {
         expected: unknown;
@@ -26,17 +26,17 @@ export type PropertyValidationError = {
     };
 };
 export type ValidationErrorInvalidProperties = {
-    code: ValidationErrorCode.InvalidProperties;
+    code: typeof ValidationErrorCode.InvalidProperties;
     details: Record<string, PropertyValidationError | ValidationError>;
 };
 export type ValidationErrorMissingProperties = {
-    code: ValidationErrorCode.MissingProperties;
+    code: typeof ValidationErrorCode.MissingProperties;
     details: Record<string, {
         type: 'missing';
     }>;
 };
 export type ValidationErrorEmptyTarget = {
-    code: ValidationErrorCode.EmptyTarget;
+    code: typeof ValidationErrorCode.EmptyTarget;
     details: {};
 };
 export type ValidationError = ValidationErrorInvalidProperties | ValidationErrorMissingProperties | ValidationErrorEmptyTarget;

package/dist/validation.js

@@ -1,25 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TraverseError = exports.PropertyValidationErrorCode = exports.ValidationErrorCode = void 0;
-var ValidationErrorCode;
-(function (ValidationErrorCode) {
-    ValidationErrorCode["InvalidProperties"] = "INVALID_PROPERTIES";
-    ValidationErrorCode["MissingProperties"] = "MISSING_PROPERTIES";
-    ValidationErrorCode["EmptyTarget"] = "EMPTY_TARGET";
-})(ValidationErrorCode || (exports.ValidationErrorCode = ValidationErrorCode = {}));
-var PropertyValidationErrorCode;
-(function (PropertyValidationErrorCode) {
-    PropertyValidationErrorCode["Missing"] = "MISSING_PROPERTY";
-    PropertyValidationErrorCode["Extraneous"] = "EXTRANEOUS_PROPERTY";
-    PropertyValidationErrorCode["Unmatching"] = "UNMATCHING_PROPERTIES";
-    PropertyValidationErrorCode["ExtraneousElement"] = "EXTRANEOUS_ELEMENT";
-    PropertyValidationErrorCode["MoreItemsExpected"] = "MORE_ITEMS_EXPECTED";
-    PropertyValidationErrorCode["LessItemsExpected"] = "LESS_ITEMS_EXPECTED";
-    PropertyValidationErrorCode["NumericConstraint"] = "NUMERIC_CONSTRAINT";
-    PropertyValidationErrorCode["StringConstraint"] = "STRING_CONSTRAINT";
-})(PropertyValidationErrorCode || (exports.PropertyValidationErrorCode = PropertyValidationErrorCode = {}));
-var TraverseError;
-(function (TraverseError) {
-    TraverseError["InvalidDocumentId"] = "INVALID_DOCUMENT_ID";
-    TraverseError["InvalidTempfile"] = "INVALID_TEMPFILE";
-})(TraverseError || (exports.TraverseError = TraverseError = {}));
+exports.ValidationErrorCode = {
+    InvalidProperties: 'INVALID_PROPERTIES',
+    MissingProperties: 'MISSING_PROPERTIES',
+    EmptyTarget: 'EMPTY_TARGET',
+};
+exports.PropertyValidationErrorCode = {
+    Missing: 'MISSING_PROPERTY',
+    Extraneous: 'EXTRANEOUS_PROPERTY',
+    Unmatching: 'UNMATCHING_PROPERTIES',
+    ExtraneousElement: 'EXTRANEOUS_ELEMENT',
+    MoreItemsExpected: 'MORE_ITEMS_EXPECTED',
+    LessItemsExpected: 'LESS_ITEMS_EXPECTED',
+    NumericConstraint: 'NUMERIC_CONSTRAINT',
+    StringConstraint: 'STRING_CONSTRAINT',
+};
+exports.TraverseError = {
+    InvalidDocumentId: 'INVALID_DOCUMENT_ID',
+    InvalidTempfile: 'INVALID_TEMPFILE',
+};

package/dist/validation.mjs

@@ -1,23 +1,20 @@
 "use strict";
-export var ValidationErrorCode = /* @__PURE__ */ ((ValidationErrorCode2) => {
-  ValidationErrorCode2["InvalidProperties"] = "INVALID_PROPERTIES";
-  ValidationErrorCode2["MissingProperties"] = "MISSING_PROPERTIES";
-  ValidationErrorCode2["EmptyTarget"] = "EMPTY_TARGET";
-  return ValidationErrorCode2;
-})(ValidationErrorCode || {});
-export var PropertyValidationErrorCode = /* @__PURE__ */ ((PropertyValidationErrorCode2) => {
-  PropertyValidationErrorCode2["Missing"] = "MISSING_PROPERTY";
-  PropertyValidationErrorCode2["Extraneous"] = "EXTRANEOUS_PROPERTY";
-  PropertyValidationErrorCode2["Unmatching"] = "UNMATCHING_PROPERTIES";
-  PropertyValidationErrorCode2["ExtraneousElement"] = "EXTRANEOUS_ELEMENT";
-  PropertyValidationErrorCode2["MoreItemsExpected"] = "MORE_ITEMS_EXPECTED";
-  PropertyValidationErrorCode2["LessItemsExpected"] = "LESS_ITEMS_EXPECTED";
-  PropertyValidationErrorCode2["NumericConstraint"] = "NUMERIC_CONSTRAINT";
-  PropertyValidationErrorCode2["StringConstraint"] = "STRING_CONSTRAINT";
-  return PropertyValidationErrorCode2;
-})(PropertyValidationErrorCode || {});
-export var TraverseError = /* @__PURE__ */ ((TraverseError2) => {
-  TraverseError2["InvalidDocumentId"] = "INVALID_DOCUMENT_ID";
-  TraverseError2["InvalidTempfile"] = "INVALID_TEMPFILE";
-  return TraverseError2;
-})(TraverseError || {});
+export const ValidationErrorCode = {
+  InvalidProperties: "INVALID_PROPERTIES",
+  MissingProperties: "MISSING_PROPERTIES",
+  EmptyTarget: "EMPTY_TARGET"
+};
+export const PropertyValidationErrorCode = {
+  Missing: "MISSING_PROPERTY",
+  Extraneous: "EXTRANEOUS_PROPERTY",
+  Unmatching: "UNMATCHING_PROPERTIES",
+  ExtraneousElement: "EXTRANEOUS_ELEMENT",
+  MoreItemsExpected: "MORE_ITEMS_EXPECTED",
+  LessItemsExpected: "LESS_ITEMS_EXPECTED",
+  NumericConstraint: "NUMERIC_CONSTRAINT",
+  StringConstraint: "STRING_CONSTRAINT"
+};
+export const TraverseError = {
+  InvalidDocumentId: "INVALID_DOCUMENT_ID",
+  InvalidTempfile: "INVALID_TEMPFILE"
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeriajs/types",
-  "version": "0.0.114",
+  "version": "0.0.116",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",