@appweaver/client 1.0.0

package/clients/modules/resource-client.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceClient = void 0;
+const base_module_1 = require("./base-module");
+class ResourceClient extends base_module_1.BaseModule {
+    basePath;
+    constructor(client, basePath) {
+        super(client);
+        this.basePath = basePath;
+    }
+    /**
+     * Fetches a single resource by its numeric ID.
+     *
+     * @param {number} id - The ID of the resource to retrieve.
+     * @param {RequestOptions} options - Additional request options (headers, query params, etc.).
+     * @returns The resource record matching the given ID.
+     */
+    async find(id, options = {}) {
+        return this.sendRequest('get', `${this.basePath}/{id}`, {
+            ...options,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id
+                }
+            }
+        });
+    }
+    /**
+     * Executes a query against the resource collection.
+     *
+     * @param {Object} request - The query payload (filters, sorting, pagination, etc.).
+     * @param {RequestOptions}  options - Additional request options.
+     * @returns A paginated or filtered list of matching resource records.
+     */
+    async query(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/query`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Runs an aggregation query (e.g., count, sum, avg) against the resource collection.
+     *
+     * @param {Object} request - The aggregation payload describing the desired computation.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The aggregated result for the given query.
+     */
+    async aggregate(request, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/aggregate`, {
+            ...options,
+            body: request
+        });
+    }
+    /**
+     * Creates a new resource record.
+     *
+     * @param {Object} resource - The data for the resource to create.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The newly created resource record.
+     */
+    async create(resource, options = {}) {
+        return this.sendRequest('post', `${this.basePath}`, {
+            ...options,
+            body: resource
+        });
+    }
+    /**
+     * Updates an existing resource record identified by `id`.
+     *
+     * @param {Object} resource - The updated field values including the mandatory `id`.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The updated resource record.
+     */
+    async update(resource, options = {}) {
+        return this.sendRequest('put', `${this.basePath}/{id}`, {
+            ...options,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id: resource['id']
+                }
+            },
+            body: resource
+        });
+    }
+    /**
+     * Deletes a resource record by its numeric ID.
+     *
+     * @param {number} id - The ID of the resource to delete.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The deleted resource record.
+     */
+    async delete(id, options = {}) {
+        return this.sendRequest('delete', `${this.basePath}/{id}`, {
+            ...options,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id
+                }
+            }
+        });
+    }
+    /**
+     * Exports resource records as a file (e.g., CSV) and returns a streaming response.
+     *
+     * @param {Object} request - The export request payload (filters, format, etc.).
+     * @param {RequestOptions} options - Additional request options.
+     * @returns {@link FileDataResponse} containing the readable stream and file metadata.
+     */
+    async export(request, options = {}) {
+        const { error, response } = await this.sendRequestRaw('post', `${this.basePath}/export`, {
+            ...options,
+            parseAs: 'stream',
+            body: request
+        });
+        if (error) {
+            this.handleError(error, response);
+        }
+        return this.toFileResponse(response);
+    }
+    /**
+     * Uploads one or more files to the resource record.
+     *
+     * Each entry in `files` maps a field name to a single `File` or an array of `File` objects.
+     *
+     * @param {number} id - The ID of the resource for which to upload files.
+     * @param {Object} files - A map of field names to the file(s) to upload.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The updated file metadata for the resource.
+     */
+    async uploadFiles(id, files, options = {}) {
+        const formData = new FormData();
+        for (const [fieldName, fileData] of Object.entries(files)) {
+            if (Array.isArray(fileData)) {
+                for (const file of fileData) {
+                    formData.append(fieldName, file);
+                }
+            }
+            else {
+                formData.append(fieldName, fileData);
+            }
+        }
+        return this.sendRequest('post', `${this.basePath}/{id}/files`, {
+            ...options,
+            body: formData,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id
+                }
+            }
+        });
+    }
+    /**
+     * Removes specific files from the resource record.
+     *
+     * @param {number} id - The ID of the resource for which to delete files.
+     * @param {Object} files - The file deletion payload identifying which files to remove.
+     * @param {RequestOptions} options - Additional request options.
+     * @returns The updated file metadata for the resource after deletion.
+     */
+    async deleteFiles(id, files, options = {}) {
+        return this.sendRequest('post', `${this.basePath}/{id}/delete-files`, {
+            ...options,
+            body: files,
+            params: {
+                ...(options.params ?? {}),
+                path: {
+                    id
+                }
+            }
+        });
+    }
+}
+exports.ResourceClient = ResourceClient;

package/clients/responses/file-data-response.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Response object containing file data and metadata from a file download request.
+ * Provides helper methods to consume the stream as text, base64 data URL, or Buffer.
+ */
+export declare class FileDataResponse {
+    /** Readable stream of the file content. */
+    readonly stream: ReadableStream;
+    /** Name of the file extracted from the Content-Disposition header or provided default. */
+    readonly fileName: string;
+    /** MIME type of the file from the Content-Type header. */
+    readonly type: string;
+    /** Size of the file in bytes from the Content-Length header. */
+    readonly length: number;
+    /** Range information if the response is a partial content response (HTTP 206). */
+    readonly range?: FileContentRange;
+    /** Cache duration in seconds from the Cache-Control max-age directive. */
+    readonly maxAge?: number;
+    /** Expiration timestamp from Expires header. */
+    readonly expiresAt?: string;
+    private _buffer;
+    constructor(data: {
+        stream: ReadableStream;
+        fileName: string;
+        type: string;
+        length: number;
+        range?: FileContentRange;
+        maxAge?: number;
+        expiresAt?: string;
+    });
+    /**
+     * Reads and returns the content of the buffer as an ArrayBuffer.
+     *
+     * @return {Promise<ArrayBuffer>} A promise that resolves to an ArrayBuffer containing the data read from the buffer.
+     */
+    buffer(): Promise<ArrayBuffer>;
+    /**
+     * Reads and returns the content of the buffer as a Blob object.
+     *
+     * The method reads an ArrayBuffer from an internal data source, then constructs,
+     * and returns a Blob object using the buffer's content and a specified MIME type.
+     *
+     * @return {Promise<Blob>} A promise that resolves to a Blob object containing the read data.
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Reads and decodes the content of the buffer into a string using the TextDecoder API.
+     *
+     * @param {string} encoding - The character encoding to use for decoding. Defaults to 'utf-8'.
+     * @return {Promise<string>} A promise that resolves to the decoded string.
+     */
+    text(encoding?: string): Promise<string>;
+    /**
+     * Reads and converts the buffer into a Base64-encoded data URL string.
+     *
+     * @return {Promise<string>} A promise that resolves to a Base64-encoded string
+     * representing the file, prefixed with the appropriate data MIME type.
+     */
+    base64(): Promise<string>;
+    /**
+     * Reads and concatenates data chunks from a readable stream into a single ArrayBuffer.
+     * If the buffer has already been read, it returns the cached ArrayBuffer.
+     *
+     * @return {Promise<ArrayBuffer>} A promise that resolves to the ArrayBuffer containing
+     * the concatenated data from the stream.
+     */
+    private _readArrayBuffer;
+}
+/**
+ * Represents byte range information for partial content responses.
+ */
+export type FileContentRange = {
+    /** Starting byte position of the range (inclusive). */
+    start: number;
+    /** Ending byte position of the range (inclusive). */
+    end: number;
+    /** Total size of the complete file in bytes. */
+    total: number;
+};

package/clients/responses/file-data-response.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileDataResponse = void 0;
+/**
+ * Response object containing file data and metadata from a file download request.
+ * Provides helper methods to consume the stream as text, base64 data URL, or Buffer.
+ */
+class FileDataResponse {
+    /** Readable stream of the file content. */
+    stream;
+    /** Name of the file extracted from the Content-Disposition header or provided default. */
+    fileName;
+    /** MIME type of the file from the Content-Type header. */
+    type;
+    /** Size of the file in bytes from the Content-Length header. */
+    length;
+    /** Range information if the response is a partial content response (HTTP 206). */
+    range;
+    /** Cache duration in seconds from the Cache-Control max-age directive. */
+    maxAge;
+    /** Expiration timestamp from Expires header. */
+    expiresAt;
+    _buffer;
+    constructor(data) {
+        this.stream = data.stream;
+        this.fileName = data.fileName;
+        this.type = data.type;
+        this.length = data.length;
+        this.range = data.range;
+        this.maxAge = data.maxAge;
+        this.expiresAt = data.expiresAt;
+    }
+    /**
+     * Reads and returns the content of the buffer as an ArrayBuffer.
+     *
+     * @return {Promise<ArrayBuffer>} A promise that resolves to an ArrayBuffer containing the data read from the buffer.
+     */
+    async buffer() {
+        return this._readArrayBuffer();
+    }
+    /**
+     * Reads and returns the content of the buffer as a Blob object.
+     *
+     * The method reads an ArrayBuffer from an internal data source, then constructs,
+     * and returns a Blob object using the buffer's content and a specified MIME type.
+     *
+     * @return {Promise<Blob>} A promise that resolves to a Blob object containing the read data.
+     */
+    async blob() {
+        const buf = await this._readArrayBuffer();
+        return new Blob([buf], { type: this.type });
+    }
+    /**
+     * Reads and decodes the content of the buffer into a string using the TextDecoder API.
+     *
+     * @param {string} encoding - The character encoding to use for decoding. Defaults to 'utf-8'.
+     * @return {Promise<string>} A promise that resolves to the decoded string.
+     */
+    async text(encoding = 'utf-8') {
+        const buf = await this._readArrayBuffer();
+        return new TextDecoder(encoding).decode(buf);
+    }
+    /**
+     * Reads and converts the buffer into a Base64-encoded data URL string.
+     *
+     * @return {Promise<string>} A promise that resolves to a Base64-encoded string
+     * representing the file, prefixed with the appropriate data MIME type.
+     */
+    async base64() {
+        const buf = await this._readArrayBuffer();
+        const bytes = new Uint8Array(buf);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        const encoded = btoa(binary);
+        return `data:${this.type};base64,${encoded}`;
+    }
+    /**
+     * Reads and concatenates data chunks from a readable stream into a single ArrayBuffer.
+     * If the buffer has already been read, it returns the cached ArrayBuffer.
+     *
+     * @return {Promise<ArrayBuffer>} A promise that resolves to the ArrayBuffer containing
+     * the concatenated data from the stream.
+     */
+    async _readArrayBuffer() {
+        if (this._buffer !== undefined) {
+            return this._buffer;
+        }
+        const reader = this.stream.getReader();
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+        }
+        const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        this._buffer = result.buffer;
+        return this._buffer;
+    }
+}
+exports.FileDataResponse = FileDataResponse;

package/clients/responses/index.d.ts

@@ -0,0 +1 @@
+export * from './file-data-response';

package/clients/responses/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./file-data-response"), exports);

package/commands/generate-command.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function generateCommand(program: Command): void;
+export declare function relativePathFrom(firstPath: string, otherPath: string): string;

package/commands/generate-command.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = generateCommand;
+exports.relativePathFrom = relativePathFrom;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const prettier_1 = __importDefault(require("prettier"));
+const commander_1 = require("commander");
+const generators_1 = require("../generators");
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+function generateCommand(program) {
+    program
+        .command('generate')
+        .alias('g')
+        .description('Generates types and client class.')
+        .argument('<schemaPath>', 'The path to the OpenAPI schema (file or URL)', parseSchema)
+        .option('--outputPath [path]', 'Output path for both generated types and client class.', './generated/client.ts')
+        .option('--typesPath [path]', 'Output path for generated types. (default: output path)')
+        .option('--clientPath [path]', 'Output path for generated client class. (default: output path)')
+        .option('--clientName [name]', 'Name for generated client class. (default: OpenAPI schema title)')
+        .option('--framework [name]', `The framework for generated client class (${constants_1.FRAMEWORKS.join(', ')})`, parseFramework, 'fetch')
+        .option('--typesOnly', 'Generate TypeScript types only (without client class).')
+        .option('--clientOnly', 'Generate only client class (without TypeScript types).')
+        .option('--noTypes', 'Generate client class without TypeScript type support.')
+        .action(async (schemaPath, _, command) => {
+        const outputPath = command.getOptionValue('outputPath');
+        const typesPath = command.getOptionValue('typesPath') || outputPath;
+        const clientPath = command.getOptionValue('clientPath') || outputPath;
+        const clientName = command.getOptionValue('clientName');
+        const framework = command.getOptionValue('framework');
+        const typesOnly = command.getOptionValue('typesOnly');
+        const clientOnly = command.getOptionValue('clientOnly');
+        const noTypes = command.getOptionValue('noTypes');
+        const cwd = process.cwd();
+        const schemaContent = await (0, utils_1.readSchemaContent)(schemaPath);
+        const schemaObject = await (0, utils_1.toSchemaObject)(schemaContent);
+        if (!clientOnly && !noTypes) {
+            const typesContent = await (0, generators_1.generateTypes)(schemaObject);
+            await formatAndWriteFile(typesPath, typesContent, typesOnly || typesPath !== clientPath);
+            console.log(`Generated types to ${node_path_1.default.relative(cwd, typesPath)}`);
+        }
+        if (!typesOnly) {
+            const typesImportPath = typesPath === clientPath
+                ? undefined
+                : relativePathFrom(clientPath, typesPath);
+            const clientContent = await (0, generators_1.generateClient)(schemaObject, clientName, framework, typesImportPath, noTypes);
+            await formatAndWriteFile(clientPath, clientContent, true, typesPath === clientPath);
+            console.log(`Generated client to ${node_path_1.default.relative(cwd, clientPath)}`);
+        }
+    });
+}
+async function formatAndWriteFile(filePath, content, addGeneratedComment = true, appendIfExists = false) {
+    const dirPath = node_path_1.default.resolve(node_path_1.default.dirname(filePath));
+    const dirExists = await pathExists(dirPath);
+    if (!dirExists) {
+        await promises_1.default.mkdir(dirPath, { recursive: true });
+    }
+    const prettierConfig = await prettier_1.default.resolveConfig(filePath);
+    let formattedContent = await prettier_1.default.format(content, {
+        ...(prettierConfig ?? { singleQuote: true, trailingComma: 'none' }),
+        filepath: filePath
+    });
+    const fileExists = await pathExists(filePath);
+    if (appendIfExists && fileExists) {
+        const existingContent = await promises_1.default.readFile(filePath, 'utf8');
+        formattedContent = formattedContent + '\n' + existingContent;
+    }
+    if (addGeneratedComment) {
+        formattedContent =
+            '// Generated by Appweaver. Please do not edit this file manually.\n\n' +
+                formattedContent;
+    }
+    await promises_1.default.writeFile(filePath, formattedContent, 'utf8');
+}
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath, promises_1.default.constants.F_OK);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function relativePathFrom(firstPath, otherPath) {
+    const firstDir = node_path_1.default.dirname(node_path_1.default.resolve(firstPath));
+    const otherAbs = node_path_1.default.resolve(otherPath);
+    let rel = node_path_1.default.relative(firstDir, otherAbs);
+    if (!rel.startsWith('.') && rel !== '') {
+        rel = `.${node_path_1.default.sep}${rel}`;
+    }
+    else if (rel === '') {
+        rel = '.';
+    }
+    if (rel.endsWith('.ts')) {
+        rel = rel.replace('.d.ts', '.ts').replace('.ts', '');
+    }
+    return rel.replace(/\\/g, '/');
+}
+function parseSchema(value) {
+    let schemaUrl;
+    try {
+        schemaUrl = new URL(value);
+    }
+    catch {
+        // Schema path is not in URL format
+    }
+    if (schemaUrl) {
+        if (!['http:', 'https:', 'file:'].includes(schemaUrl.protocol)) {
+            throw new commander_1.InvalidArgumentError(`Unsupported schema URL protocol: ${schemaUrl.protocol}`);
+        }
+        return value;
+    }
+    if (!node_fs_1.default.existsSync(value)) {
+        throw new commander_1.InvalidArgumentError(`Schema path "${value}" does not exist or is not a valid URL.`);
+    }
+    return value;
+}
+function parseFramework(value) {
+    const lowerFramework = value.toLowerCase();
+    if (!constants_1.FRAMEWORKS.includes(lowerFramework)) {
+        throw new commander_1.InvalidOptionArgumentError(`Must be one of following: ${constants_1.FRAMEWORKS.join(', ')}.`);
+    }
+    return lowerFramework;
+}

package/commands/index.d.ts

@@ -0,0 +1 @@
+export * from './generate-command';

package/commands/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generate-command"), exports);

package/constants.d.ts

@@ -0,0 +1,67 @@
+/** Supported frameworks for generating the client class. */
+export declare const FRAMEWORKS: readonly ["fetch", "angular"];
+/** Custom OpenAPI extension key used for extracting route prefixes and base paths to their resources. */
+export declare const CONFIG_FIELD = "x-appweaver-config";
+/** Custom OpenAPI extension key used for extracting resources names from schema CRUD objects. */
+export declare const CONFIG_RESOURCE_FIELD = "x-appweaver-resource";
+/** Suffix used when generating the TypeScript module type name for a resource. */
+export declare const RESOURCE_MODULE_TYPE = "ResourceModuleType";
+/** Maps CRUD operation names to HTTP methods used for matching OpenAPI paths to `ResourceClient` methods. */
+export declare const RESOURCE_OPERATIONS: {
+    readonly find: "get";
+    readonly query: "post";
+    readonly aggregate: "post";
+    readonly create: "post";
+    readonly update: "put";
+    readonly delete: "delete";
+    readonly export: "post";
+    readonly uploadFiles: "post";
+    readonly deleteFiles: "post";
+};
+/** Expected type keys for a resource used for type inference. */
+export declare const RESOURCE_TYPES: readonly ["single", "multiple", "create", "update", "queryRequest", "queryResponse", "aggregateRequest", "aggregateResponse", "exportRequest", "files", "fileUpload", "fileDelete"];
+/** Type name used when generating the TypeScript module type for the auth module. */
+export declare const AUTH_MODULE_TYPE = "AuthModuleType";
+/** Maps auth operation names to HTTP methods used for matchingOpenAPI paths to `AuthClient` methods.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export declare const AUTH_OPERATIONS: {
+    readonly login: "post";
+    readonly logout: "post";
+    readonly refresh: "post";
+    readonly changePassword: "post";
+    readonly exchangeToken: "post";
+    readonly me: "get";
+};
+/** Expected type keys for the auth module used for type safety. */
+export declare const AUTH_TYPES: readonly ["loginRequest", "authenticationResponse", "logoutResponse", "changePasswordRequest", "exchangeTokenRequest", "identity"];
+/** Type name used when generating the TypeScript module type for the account module. */
+export declare const ACCOUNT_MODULE_TYPE = "AccountModuleType";
+/** Maps account operation names to HTTP methods used for matching OpenAPI paths to `AccountClient` methods.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export declare const ACCOUNT_OPERATIONS: {
+    readonly sendVerifyEmail: "post";
+    readonly verifyEmail: "post";
+    readonly verifyEmailRedirect: "get";
+    readonly sendResetPassword: "post";
+    readonly resetPassword: "post";
+    readonly send2FACode: "post";
+    readonly verify2FACode: "post";
+};
+/** Expected type keys for the account module which covers email verification, password reset, and 2FA req/resp. */
+export declare const ACCOUNT_TYPES: readonly ["sendEmailVerificationRequest", "statusResponse", "emailVerificationRequest", "sendResetPasswordRequest", "resetPasswordRequest", "send2FACodeRequest", "send2FAResponse", "verify2FARequest", "verify2FAResponse"];
+/** Type name used when generating the TypeScript module type for the health module. */
+export declare const HEALTH_MODULE_TYPE = "HealthModuleType";
+/** Maps health check operations to HTTP GET methods used for matching OpenAPI paths to `HealthClient` methods.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export declare const HEALTH_OPERATIONS: {
+    readonly check: "get";
+    readonly ready: "get";
+};
+/** Expected type keys for the health module used for `HealthClient` response typing. */
+export declare const HEALTH_TYPES: readonly ["checkResponse", "readyResponse"];
+/** Maps file-serving operations to HTTP GET methods used for identifying public and protected file endpoints.
+ * The operation names are matching the real API paths (without a prefix and in camelCase format) from the OpenAPI. */
+export declare const FILE_OPERATIONS: {
+    readonly public: "get";
+    readonly protected: "get";
+};