@aeriajs/types 0.0.51 → 0.0.53

package/dist/accessControl.d.ts

@@ -6,11 +6,10 @@ export declare enum ACError {
     AuthorizationError = "AUTHORIZATION_ERROR",
     FunctionNotFound = "FUNCTION_NOT_FOUND",
     FunctionNotExposed = "FUNCTION_NOT_EXPOSED",
-    ImmutabilityIncorrectChild = "IMMUTABILITY_INCORRECT_CHILD",
-    ImmutabilityParentNotFound = "IMMUTABILITY_PARENT_NOT_FOUND",
-    ImmutabilityTargetImmutable = "IMMUTABILITY_TARGET_IMMUTABLE",
+    TargetImmutable = "TARGET_IMMUTABLE",
     InvalidLimit = "INVALID_LIMIT",
     OwnershipError = "OWNERSHIP_ERROR",
-    ResourceNotFound = "RESOURCE_NOT_FOUND"
+    ResourceNotFound = "RESOURCE_NOT_FOUND",
+    InsecureOperator = "INSECURE_OPERATOR",
+    MalformedInput = "MALFORMED_INPUT"
 }
-export declare const ACErrorMessages: Record<ACError, string>;

package/dist/accessControl.js

@@ -1,28 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ACErrorMessages = exports.ACError = void 0;
+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["ImmutabilityIncorrectChild"] = "IMMUTABILITY_INCORRECT_CHILD";
-    ACError["ImmutabilityParentNotFound"] = "IMMUTABILITY_PARENT_NOT_FOUND";
-    ACError["ImmutabilityTargetImmutable"] = "IMMUTABILITY_TARGET_IMMUTABLE";
+    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 || (exports.ACError = ACError = {}));
-exports.ACErrorMessages = {
-    [ACError.AuthenticationError]: 'you have insufficient privileges',
-    [ACError.AuthorizationError]: 'you have insufficient privileges',
-    [ACError.FunctionNotFound]: 'function not found',
-    [ACError.FunctionNotExposed]: 'function not exposed',
-    [ACError.ImmutabilityIncorrectChild]: 'specified limit is invalid',
-    [ACError.ImmutabilityParentNotFound]: 'specified limit is invalid',
-    [ACError.ImmutabilityTargetImmutable]: 'specified limit is invalid',
-    [ACError.InvalidLimit]: 'specified limit is invalid',
-    [ACError.OwnershipError]: 'you have insufficient privileges',
-    [ACError.ResourceNotFound]: 'collection not found',
-};

package/dist/accessControl.mjs

@@ -4,23 +4,11 @@ export var ACError = /* @__PURE__ */ ((ACError2) => {
   ACError2["AuthorizationError"] = "AUTHORIZATION_ERROR";
   ACError2["FunctionNotFound"] = "FUNCTION_NOT_FOUND";
   ACError2["FunctionNotExposed"] = "FUNCTION_NOT_EXPOSED";
-  ACError2["ImmutabilityIncorrectChild"] = "IMMUTABILITY_INCORRECT_CHILD";
-  ACError2["ImmutabilityParentNotFound"] = "IMMUTABILITY_PARENT_NOT_FOUND";
-  ACError2["ImmutabilityTargetImmutable"] = "IMMUTABILITY_TARGET_IMMUTABLE";
+  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";
   return ACError2;
 })(ACError || {});
-export const ACErrorMessages = {
-  ["AUTHENTICATION_ERROR" /* AuthenticationError */]: "you have insufficient privileges",
-  ["AUTHORIZATION_ERROR" /* AuthorizationError */]: "you have insufficient privileges",
-  ["FUNCTION_NOT_FOUND" /* FunctionNotFound */]: "function not found",
-  ["FUNCTION_NOT_EXPOSED" /* FunctionNotExposed */]: "function not exposed",
-  ["IMMUTABILITY_INCORRECT_CHILD" /* ImmutabilityIncorrectChild */]: "specified limit is invalid",
-  ["IMMUTABILITY_PARENT_NOT_FOUND" /* ImmutabilityParentNotFound */]: "specified limit is invalid",
-  ["IMMUTABILITY_TARGET_IMMUTABLE" /* ImmutabilityTargetImmutable */]: "specified limit is invalid",
-  ["INVALID_LIMIT" /* InvalidLimit */]: "specified limit is invalid",
-  ["OWNERSHIP_ERROR" /* OwnershipError */]: "you have insufficient privileges",
-  ["RESOURCE_NOT_FOUND" /* ResourceNotFound */]: "collection not found"
-};

package/dist/collection.d.ts

@@ -7,11 +7,10 @@ export type Collection<TCollection extends Collection = any> = {
     description: Description;
     item?: any;
     security?: CollectionSecurityPolicy<TCollection>;
-    functions?: Record<string, (payload: any, context: Context, ...args: any[]) => any>;
+    functions?: Record<string, (payload: any, context: Context<any>, ...args: any[]) => any>;
     contracts?: Record<string, Contract>;
     exposedFunctions?: Record<string, AccessCondition>;
 };
 export type CollectionItem<TCollectionName extends keyof Collections> = Omit<Collections[TCollectionName]['item'], '_id'>;
 export type CollectionItemWithId<TCollectionName extends keyof Collections> = Collections[TCollectionName]['item'];
 export type AssetType = keyof Collection;
-export type FunctionPath = `/${string}/${string}`;

package/dist/context.d.ts

@@ -3,15 +3,14 @@ import type { AcceptedRole } from './token.js';
 import type { ApiConfig } from './config.js';
 import type { CollectionDocument, CollectionFunctions } from './functions.js';
 import type { Description } from './description.js';
-import type { Either, EndpointError, EndpointErrorContent } from './monad.js';
-import type { FunctionPath } from './collection.js';
+import type { EndpointError, EndpointErrorContent } from './error.js';
 import type { GenericRequest, GenericResponse, HTTPStatus } from './http.js';
 import type { PackReferences, SchemaWithId } from './schema.js';
-import type { RateLimitingParams, RateLimitingErrors } from './security.js';
+import type { RateLimitingParams, RateLimitingError } from './security.js';
 import type { Token } from './token.js';
 export type CollectionModel<TDescription extends Description> = MongoCollection<Omit<PackReferences<SchemaWithId<TDescription>>, '_id'>>;
 type OmitContextParameter<TFunction> = TFunction extends () => any ? TFunction : TFunction extends (payload: undefined, ...args: any[]) => infer Return ? () => Return : TFunction extends (payload: infer Payload, context: Context, ...args: infer Rest) => infer Return ? (payload: Payload, ...args: Rest) => Return : never;
-type RestParameters<TFunction> = TFunction extends (payload: any, context: Context, ...args: infer Rest) => any ? Rest : never;
+type RestParameters<TFunction> = TFunction extends (payload: any, context: Context<any>, ...args: infer Rest) => any ? Rest : never;
 type UnionFunctions<TFunctions, TSchema extends CollectionDocument<any>> = {
     [P in keyof TFunctions]: (P extends keyof CollectionFunctions<any> ? CollectionFunctions<TSchema>[P] extends infer CollFunction ? CollFunction extends (...args: any[]) => any ? Extract<undefined, Parameters<CollFunction>[0]> extends never ? (payload: Parameters<CollFunction>[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : (payload?: Parameters<CollFunction>[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : never : never : OmitContextParameter<TFunctions[P]>) extends (...args: infer Args) => infer Return ? Return extends Promise<any> ? (...args: Args) => Return : (...args: Args) => Promise<Return> : never;
 };
@@ -36,18 +35,19 @@ export type ContextOptions = {
 };
 export type RouteContext<TAcceptedRole extends AcceptedRole = null> = {
     collections: IndepthCollections;
-    functionPath: FunctionPath;
     token: Token<TAcceptedRole>;
     request: GenericRequest;
     response: GenericResponse;
     log: (message: string, details?: any) => Promise<any>;
-    error: <TEndpointErrorContent extends Omit<EndpointErrorContent, 'httpStatus'>>(httpStatus: HTTPStatus, error: TEndpointErrorContent) => EndpointError<TEndpointErrorContent>;
-    limitRate: (params: RateLimitingParams) => Promise<Either<RateLimitingErrors, {
+    error: <const THTTPStatus extends HTTPStatus, const TEndpointErrorContent extends EndpointErrorContent>(httpStatus: THTTPStatus, error: TEndpointErrorContent) => EndpointError<TEndpointErrorContent & {
+        httpStatus: THTTPStatus;
+    }>;
+    limitRate: (params: RateLimitingParams) => Promise<EndpointError<EndpointErrorContent<RateLimitingError, HTTPStatus.TooManyRequests>> | {
         hits: number;
         points: number;
         last_reach: Date;
         last_maximum_reach: Date;
-    }>>;
+    }>;
     config: ApiConfig;
     inherited: boolean;
     calledFunction: string;
@@ -60,6 +60,6 @@ export type CollectionContext<TDescription extends Description = any, TFunctions
         functions: TFunctions;
     }> : IndepthCollection<any>;
 };
-export type Context<TDescription extends Description = any, TFunctions = any> = RouteContext & CollectionContext<TDescription, TFunctions>;
+export type Context<TDescription extends Description = Description, TFunctions = any> = RouteContext & CollectionContext<TDescription, TFunctions>;
 export type StrictContext<TAcceptedRole extends AcceptedRole = null, TDescription extends Description = any, TFunctions = any> = RouteContext<TAcceptedRole> & CollectionContext<TDescription, TFunctions>;
 export {};

package/dist/description.d.ts

@@ -1,3 +1,4 @@
+import type { WithId } from 'mongodb';
 import type { IconStyle, PhosphorIcon } from '@phosphor-icons/core';
 import type { Condition } from './condition.js';
 import type { JsonSchema, PropertiesWithId } from './property.js';
@@ -87,7 +88,7 @@ export type Description<TDescription extends Description = any> = JsonSchema<TDe
         expireAfterSeconds: number;
     };
     timestamps?: false;
-    immutable?: boolean | readonly string[];
+    immutable?: boolean | readonly (keyof TDescription['properties'])[] | ((doc: WithId<any>) => boolean | Promise<boolean>);
     route?: readonly string[];
     presets?: readonly CollectionPresets[];
     table?: readonly PropertiesWithId<TDescription>[];

package/dist/{monad.d.ts → either.d.ts}

@@ -6,16 +6,6 @@ export type Right<T> = {
     readonly _tag: 'Right';
     readonly value: T;
 };
-export type EndpointErrorContent = {
-    httpStatus?: number;
-    code: string;
-    message?: string;
-    details?: Record<string, any>;
-};
-export type EndpointError<T extends EndpointErrorContent> = {
-    readonly _tag: 'Error';
-    readonly error: T;
-};
 export type ExtractLeft<T> = T extends Left<infer L> ? L : never;
 export type ExtractRight<T> = T extends Right<infer R> ? R : never;
 export type Either<L, R> = Left<L> | Right<R>;

package/dist/error.d.ts

@@ -0,0 +1,21 @@
+import type { HTTPStatus } from './http.js';
+export declare const ERROR_SYMBOL_DESCRIPTION = "#__ERROR_SYMBOL__";
+export declare const ERROR_SYMBOL: unique symbol;
+export type EndpointErrorContent<TCode extends string = string, TDetails = unknown, THTTPStatus extends HTTPStatus = HTTPStatus, TMessage extends string = string> = {
+    code: TCode;
+    details?: TDetails;
+    httpStatus?: THTTPStatus;
+    message?: TMessage;
+};
+export type StrictEndpointErrorContent<TCode extends string = string, TDetails = unknown, THTTPStatus extends HTTPStatus | undefined = HTTPStatus, TMessage extends string | undefined = string> = {
+    code: TCode;
+    details?: TDetails;
+    httpStatus: THTTPStatus;
+    message?: TMessage;
+};
+export type EndpointError<TEndpointErrorContent extends EndpointErrorContent = EndpointErrorContent> = {
+    readonly _tag: 'Error';
+    readonly value: TEndpointErrorContent;
+};
+export type ExtractError<T> = T extends EndpointError ? T : never;
+export type ExtractSuccessful<T> = T extends EndpointError ? never : T;

package/dist/error.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_SYMBOL = exports.ERROR_SYMBOL_DESCRIPTION = void 0;
+exports.ERROR_SYMBOL_DESCRIPTION = '#__ERROR_SYMBOL__';
+exports.ERROR_SYMBOL = Symbol(exports.ERROR_SYMBOL_DESCRIPTION);

package/dist/error.mjs

@@ -0,0 +1,3 @@
+"use strict";
+export const ERROR_SYMBOL_DESCRIPTION = "#__ERROR_SYMBOL__";
+export const ERROR_SYMBOL = Symbol(ERROR_SYMBOL_DESCRIPTION);

package/dist/functions.d.ts

@@ -1,8 +1,9 @@
 import type { FilterOperators, StrictFilter as Filter, StrictUpdateFilter, WithId, OptionalId, ObjectId } from 'mongodb';
-import type { ACError } from './accessControl.js';
-import type { Either } from './monad.js';
+import type { EndpointError, StrictEndpointErrorContent } from './error.js';
 import type { PackReferences } from './schema.js';
-import type { ValidationError } from './validation.js';
+import type { ACError } from './accessControl.js';
+import type { ValidationErrorCode } from './validation.js';
+import type { HTTPStatus, WithACErrors } from './http.js';
 export type UploadAuxProps = {
     parentId: string;
     propertyName: string;
@@ -67,19 +68,27 @@ export type RemoveFilePayload = UploadAuxProps & {
         _id: any;
     };
 };
+export type InsertReturnType<TDocument> = TDocument | EndpointError<StrictEndpointErrorContent<ACError.InsecureOperator | ACError.OwnershipError | ACError.ResourceNotFound | ACError.TargetImmutable | ValidationErrorCode, unknown, HTTPStatus.NotFound | HTTPStatus.UnprocessableContent>>;
+export type GetReturnType<TDocument> = TDocument | EndpointError<StrictEndpointErrorContent<ACError.ResourceNotFound, unknown, HTTPStatus.NotFound>>;
 export type CollectionFunctions<TDocument extends CollectionDocument<OptionalId<any>>> = {
     count: (payload: CountPayload<TDocument>) => Promise<number>;
-    get: (payload: GetPayload<TDocument>) => Promise<TDocument | null>;
+    get: (payload: GetPayload<TDocument>) => Promise<GetReturnType<TDocument>>;
     getAll: (payload?: GetAllPayload<TDocument>) => Promise<TDocument[]>;
-    insert: (payload: InsertPayload<TDocument>) => Promise<Either<ValidationError | ACError, TDocument>>;
+    insert: (payload: InsertPayload<TDocument>) => Promise<InsertReturnType<TDocument>>;
     remove: (payload: RemovePayload<TDocument>) => Promise<TDocument>;
     removeAll: (payload: RemoveAllPayload) => Promise<any>;
     removeFile: (payload: RemoveFilePayload) => Promise<any>;
 };
-export type CollectionFunctionsPaginated<TDocument extends CollectionDocument<OptionalId<any>>> = Omit<CollectionFunctions<TDocument>, 'getAll'> & {
-    getAll: (payload?: GetAllPayload<TDocument>) => Promise<{
+export type CollectionFunctionsSDK<TDocument extends CollectionDocument<OptionalId<any>>> = {
+    count: (payload: CountPayload<TDocument>) => Promise<WithACErrors<number>>;
+    get: (payload: GetPayload<TDocument>) => Promise<WithACErrors<GetReturnType<TDocument>>>;
+    getAll: (payload?: GetAllPayload<TDocument>) => Promise<WithACErrors<{
         data: TDocument[];
         pagination: Pagination;
-    }>;
+    }>>;
+    insert: (payload: InsertPayload<TDocument>) => Promise<WithACErrors<InsertReturnType<TDocument>>>;
+    remove: (payload: RemovePayload<TDocument>) => Promise<WithACErrors<TDocument>>;
+    removeAll: (payload: RemoveAllPayload) => Promise<any>;
+    removeFile: (payload: RemoveFilePayload) => Promise<any>;
 };
 export {};

package/dist/http.d.ts

@@ -1,8 +1,12 @@
 /// <reference types="node" />
 import type { ServerResponse, IncomingMessage } from 'http';
 import type { MapSchemaUnion } from './schema.js';
+import type { EndpointError, EndpointErrorContent, StrictEndpointErrorContent } from './error.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,
     BadRequest = 400,
     Unauthorized = 401,
     Forbidden = 403,
@@ -24,7 +28,10 @@ export type GenericRequest = {
     nodeRequest: IncomingMessage;
 };
 export type GenericResponse = ServerResponse;
-export type EndpointFunction<TRouteMethod extends RequestMethod, TRouteResponse, TRoutePayload> = (TRoutePayload extends null ? (payload?: any) => Promise<TRouteResponse> : TRoutePayload extends undefined ? () => Promise<TRouteResponse> : (payload: TRoutePayload) => Promise<TRouteResponse>) extends infer Function ? Record<TRouteMethod, Function> : never;
+type ExtractCode<TRouteResponse> = TRouteResponse extends EndpointError<EndpointErrorContent<infer PCode>> ? PCode : never;
+type ExtractHTTPStatus<TRouteResponse> = TRouteResponse extends EndpointError<EndpointErrorContent<any, unknown, infer PHTTPStatus>> ? PHTTPStatus : never;
+export type WithACErrors<TRouteResponse> = Exclude<TRouteResponse, EndpointError<any>> | EndpointError<StrictEndpointErrorContent<ExtractCode<TRouteResponse> | ACError.AuthenticationError | ACError.AuthorizationError | RateLimitingError.LimitReached | RateLimitingError.Unauthenticated, unknown, ExtractHTTPStatus<TRouteResponse> | HTTPStatus.Unauthorized | HTTPStatus.TooManyRequests>>;
+export type EndpointFunction<TRouteMethod extends RequestMethod, TRouteResponse, TRoutePayload> = (TRoutePayload extends null ? (payload?: any) => Promise<WithACErrors<TRouteResponse>> : TRoutePayload extends undefined ? () => Promise<WithACErrors<TRouteResponse>> : (payload: TRoutePayload) => Promise<WithACErrors<TRouteResponse>>) extends infer Function ? Record<TRouteMethod, Function> : never;
 export type MakeEndpoint<TRoute extends string, TRouteMethod extends RequestMethod, TRouteResponse = any, 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>>;
 type UnwrapResponse<TResponse> = TResponse extends readonly any[] ? TResponse : TResponse[];
 export type InferResponse<TResponse> = MapSchemaUnion<UnwrapResponse<TResponse>> extends infer InferredResponse ? InferredResponse | Promise<InferredResponse> : never;

package/dist/http.js

@@ -14,6 +14,7 @@ exports.REQUEST_METHODS = [
 ];
 var HTTPStatus;
 (function (HTTPStatus) {
+    HTTPStatus[HTTPStatus["Ok"] = 200] = "Ok";
     HTTPStatus[HTTPStatus["BadRequest"] = 400] = "BadRequest";
     HTTPStatus[HTTPStatus["Unauthorized"] = 401] = "Unauthorized";
     HTTPStatus[HTTPStatus["Forbidden"] = 403] = "Forbidden";

package/dist/http.mjs

@@ -11,6 +11,7 @@ export const REQUEST_METHODS = [
   "SEARCH"
 ];
 export var HTTPStatus = /* @__PURE__ */ ((HTTPStatus2) => {
+  HTTPStatus2[HTTPStatus2["Ok"] = 200] = "Ok";
   HTTPStatus2[HTTPStatus2["BadRequest"] = 400] = "BadRequest";
   HTTPStatus2[HTTPStatus2["Unauthorized"] = 401] = "Unauthorized";
   HTTPStatus2[HTTPStatus2["Forbidden"] = 403] = "Forbidden";

package/dist/index.d.ts

@@ -5,7 +5,8 @@ export * from './config.js';
 export * from './context.js';
 export * from './contract.js';
 export * from './description.js';
-export * from './monad.js';
+export * from './either.js';
+export * from './error.js';
 export * from './functions.js';
 export * from './http.js';
 export * from './property.js';

package/dist/index.js

@@ -21,7 +21,8 @@ __exportStar(require("./config.js"), exports);
 __exportStar(require("./context.js"), exports);
 __exportStar(require("./contract.js"), exports);
 __exportStar(require("./description.js"), exports);
-__exportStar(require("./monad.js"), exports);
+__exportStar(require("./either.js"), exports);
+__exportStar(require("./error.js"), exports);
 __exportStar(require("./functions.js"), exports);
 __exportStar(require("./http.js"), exports);
 __exportStar(require("./property.js"), exports);

package/dist/index.mjs

@@ -6,7 +6,8 @@ export * from "./config.mjs";
 export * from "./context.mjs";
 export * from "./contract.mjs";
 export * from "./description.mjs";
-export * from "./monad.mjs";
+export * from "./either.mjs";
+export * from "./error.mjs";
 export * from "./functions.mjs";
 export * from "./http.mjs";
 export * from "./property.mjs";

package/dist/schema.d.ts

@@ -41,7 +41,7 @@ export type InferProperty<T> = T extends TestType<{
     const: infer K;
 }> ? K : never;
 export type InferSchema<TSchema> = MergeReferences<TSchema> extends infer MappedTypes ? TSchema extends {
-    required: readonly [];
+    Required: readonly [];
 } ? Partial<MappedTypes> : TSchema extends {
     required: infer RequiredPropNames;
 } ? RequiredPropNames extends readonly (keyof MappedTypes)[] ? Pick<MappedTypes, RequiredPropNames[number]> extends infer RequiredProps ? RequiredProps & Partial<Exclude<MappedTypes, keyof RequiredProps>> : never : MappedTypes : MappedTypes : never;

package/dist/security.d.ts

@@ -1,5 +1,5 @@
 export type OwnershipMode = boolean | 'always' | 'on-write';
-export declare enum RateLimitingErrors {
+export declare enum RateLimitingError {
     Unauthenticated = "UNAUTHENTICATED",
     LimitReached = "LIMIT_REACHED"
 }

package/dist/security.js

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

package/dist/security.mjs

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

package/dist/token.d.ts

@@ -1,13 +1,11 @@
 import type { ObjectId } from 'mongodb';
 import type { PackReferences } from './schema.js';
-import type { FunctionPath } from './collection.js';
 export type UserRole = (Collections['user']['item']['roles'][number] extends infer UserDefinedRole ? UserDefinedRole extends string ? `${UserDefinedRole}${UserDefinedRole}` extends UserDefinedRole ? 'root' : UserDefinedRole : never : never) | 'root' | 'unauthenticated';
 export type AcceptedRole = UserRole | UserRole[] | null | unknown;
 export type AuthenticatedToken<TAcceptedRole extends AcceptedRole = null> = {
     authenticated: true;
     sub: ObjectId;
     roles: readonly (TAcceptedRole extends null ? string : TAcceptedRole)[];
-    allowed_functions?: readonly FunctionPath[];
     userinfo: Omit<Collections['user']['item'], '_id' | 'roles'> extends infer UserItem ? UserItem | PackReferences<UserItem> : never;
 };
 export type UnauthenticatedToken = {

package/dist/validation.d.ts

@@ -1,29 +1,35 @@
-export declare enum ValidationErrorCodes {
+export declare enum ValidationErrorCode {
     InvalidProperties = "INVALID_PROPERTIES",
     MissingProperties = "MISSING_PROPERTIES",
     EmptyTarget = "EMPTY_TARGET"
 }
-export type PropertyValidationErrorType = 'missing' | 'extraneous' | 'unmatching' | 'extraneous_element' | 'numeric_constraint';
+export declare enum PropertyValidationErrorCode {
+    Missing = "MISSING_PROPERTY",
+    Extraneous = "EXTRANEOUS_PROPERTY",
+    Unmatching = "UNMATCHING_PROPERTIES",
+    ExtraneousElement = "EXTRANEOUS_ELEMENT",
+    NumericConstraint = "NUMERIC_CONSTRAINT"
+}
 export type PropertyValidationError = {
-    type: PropertyValidationErrorType;
+    type: PropertyValidationErrorCode;
     index?: number;
     details: {
         expected: any;
-        got: string;
+        got: any;
     };
 };
 export type ValidationErrorInvalidProperties = {
-    code: ValidationErrorCodes.InvalidProperties;
+    code: ValidationErrorCode.InvalidProperties;
     errors: Record<string, PropertyValidationError | ValidationError>;
 };
 export type ValidationErrorMissingProperties = {
-    code: ValidationErrorCodes.MissingProperties;
+    code: ValidationErrorCode.MissingProperties;
     errors: Record<string, {
         type: 'missing';
     }>;
 };
 export type ValidationErrorEmptyTarget = {
-    code: ValidationErrorCodes.EmptyTarget;
+    code: ValidationErrorCode.EmptyTarget;
     errors: {};
 };
 export type ValidationError = ValidationErrorInvalidProperties | ValidationErrorMissingProperties | ValidationErrorEmptyTarget;

package/dist/validation.js

@@ -1,9 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationErrorCodes = void 0;
-var ValidationErrorCodes;
-(function (ValidationErrorCodes) {
-    ValidationErrorCodes["InvalidProperties"] = "INVALID_PROPERTIES";
-    ValidationErrorCodes["MissingProperties"] = "MISSING_PROPERTIES";
-    ValidationErrorCodes["EmptyTarget"] = "EMPTY_TARGET";
-})(ValidationErrorCodes || (exports.ValidationErrorCodes = ValidationErrorCodes = {}));
+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["NumericConstraint"] = "NUMERIC_CONSTRAINT";
+})(PropertyValidationErrorCode || (exports.PropertyValidationErrorCode = PropertyValidationErrorCode = {}));

package/dist/validation.mjs

@@ -1,7 +1,15 @@
 "use strict";
-export var ValidationErrorCodes = /* @__PURE__ */ ((ValidationErrorCodes2) => {
-  ValidationErrorCodes2["InvalidProperties"] = "INVALID_PROPERTIES";
-  ValidationErrorCodes2["MissingProperties"] = "MISSING_PROPERTIES";
-  ValidationErrorCodes2["EmptyTarget"] = "EMPTY_TARGET";
-  return ValidationErrorCodes2;
-})(ValidationErrorCodes || {});
+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["NumericConstraint"] = "NUMERIC_CONSTRAINT";
+  return PropertyValidationErrorCode2;
+})(PropertyValidationErrorCode || {});

package/package.json

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