@aopslab/domain-dm-docman 0.1.2

package/dist/application/services/service.sectionPageLink.js

@@ -0,0 +1,58 @@
+import { Effect } from 'effect';
+import { pipe } from 'effect/Function';
+import { validateInput, XfErrorFactory, effectErrorInfo } from '@aopslab/xf-core';
+import { sectionPageLinkZodSchemaInsert } from '../../domain/models/index.js';
+import { validateBmInputWithSchema } from './service.zod-validation.js';
+import { mapDbError } from '@aopslab/xf-db';
+export class SectionPageLinkService {
+    sectionPageLinkRepository;
+    logger;
+    constructor(options) {
+        this.sectionPageLinkRepository = options.sectionPageLinkRepository;
+        this.logger = options.logger?.child({ module: this.constructor.name });
+    }
+    getById(id, options) {
+        const stage = 'SectionPageLinkService::getById';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((id) => this.sectionPageLinkRepository.findById(id, options).pipe(Effect.mapError(mapDbError({ stage, operation: 'findById', factory: XfErrorFactory.notFound })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in getById');
+        })));
+    }
+    create(data) {
+        const stage = 'SectionPageLinkService::create';
+        return pipe(validateInput(data, 'data', { stage }), Effect.flatMap((data) => validateBmInputWithSchema({
+            input: data,
+            schema: sectionPageLinkZodSchemaInsert,
+            stage,
+            operation: 'SectionPageLinkService::create.sectionPageLinkZodSchemaInsert',
+            field: 'data',
+        })), Effect.flatMap((data) => this.sectionPageLinkRepository.create(data).pipe(Effect.mapError(mapDbError({ stage, operation: 'create', factory: XfErrorFactory.createFailed })))));
+    }
+    listSectionPageLinks(filter = {}, options) {
+        const stage = 'SectionPageLinkService::listSectionPageLinks';
+        return pipe(validateInput(filter, 'filter', { stage }), Effect.flatMap((filter) => this.sectionPageLinkRepository.find({ matchEq: filter, options }).pipe(Effect.mapError(mapDbError({ stage, operation: 'find', factory: XfErrorFactory.notFound })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in listSectionPageLinks');
+        })));
+    }
+    updateSectionPageLink(id, patch) {
+        const stage = 'SectionPageLinkService::updateSectionPageLink';
+        if (!patch || Object.keys(patch).length === 0) {
+            return Effect.fail(XfErrorFactory.inputRequired({ field: 'patch', stage }));
+        }
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((entityId) => validateBmInputWithSchema({
+            input: patch,
+            schema: sectionPageLinkZodSchemaInsert.partial().strict(),
+            stage,
+            operation: 'SectionPageLinkService::updateSectionPageLink.sectionPageLinkZodSchemaInsert.patch',
+            field: 'patch',
+        }).pipe(Effect.map(() => entityId))), Effect.flatMap((entityId) => this.sectionPageLinkRepository.patchById(entityId, patch).pipe(Effect.mapError(mapDbError({ stage, operation: 'patchById', factory: XfErrorFactory.upsertFailed })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in updateSectionPageLink');
+        })));
+    }
+    removeSectionPageLink(id) {
+        const stage = 'SectionPageLinkService::removeSectionPageLink';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((entityId) => this.sectionPageLinkRepository.deleteById(entityId).pipe(Effect.mapError(mapDbError({ stage, operation: 'deleteById', factory: XfErrorFactory.upsertFailed })))), Effect.map(() => undefined));
+    }
+}

package/dist/application/services/service.snippet.d.ts

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { XfLogger } from '@aopslab/xf-logger';
+import type { IRepositoryPortSnippet } from '../ports/repository-ports/index.js';
+import type { ISnippetServicePort } from '../ports/inbound/index.js';
+import { SnippetServiceError } from '../errors/SnippetServiceError.js';
+import { IbmSnippet, IbmSnippetInsert } from '../../domain/models/index.js';
+import { DbQueryOptions } from '@aopslab/xf-db';
+export interface SnippetServiceDependencies {
+}
+export interface SnippetServiceOptions {
+    snippetRepository: IRepositoryPortSnippet;
+    serviceDependencies?: Partial<SnippetServiceDependencies>;
+    logger?: XfLogger;
+    locale?: string;
+}
+export declare class SnippetService implements ISnippetServicePort {
+    private readonly snippetRepository;
+    private readonly logger?;
+    constructor(options: SnippetServiceOptions);
+    getById(id: string, options?: DbQueryOptions<IbmSnippet>): Effect.Effect<IbmSnippet | null, SnippetServiceError>;
+    create(data: IbmSnippetInsert): Effect.Effect<IbmSnippet, SnippetServiceError>;
+    listSnippets(filter?: Partial<IbmSnippet>, options?: DbQueryOptions<IbmSnippet>): Effect.Effect<IbmSnippet[], SnippetServiceError>;
+    updateSnippet(id: string, patch: Partial<IbmSnippet>): Effect.Effect<IbmSnippet, SnippetServiceError>;
+    removeSnippet(id: string): Effect.Effect<void, SnippetServiceError>;
+}

package/dist/application/services/service.snippet.js

@@ -0,0 +1,58 @@
+import { Effect } from 'effect';
+import { pipe } from 'effect/Function';
+import { validateInput, XfErrorFactory, effectErrorInfo } from '@aopslab/xf-core';
+import { snippetZodSchemaInsert } from '../../domain/models/index.js';
+import { validateBmInputWithSchema } from './service.zod-validation.js';
+import { mapDbError } from '@aopslab/xf-db';
+export class SnippetService {
+    snippetRepository;
+    logger;
+    constructor(options) {
+        this.snippetRepository = options.snippetRepository;
+        this.logger = options.logger?.child({ module: this.constructor.name });
+    }
+    getById(id, options) {
+        const stage = 'SnippetService::getById';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((id) => this.snippetRepository.findById(id, options).pipe(Effect.mapError(mapDbError({ stage, operation: 'findById', factory: XfErrorFactory.notFound })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in getById');
+        })));
+    }
+    create(data) {
+        const stage = 'SnippetService::create';
+        return pipe(validateInput(data, 'data', { stage }), Effect.flatMap((data) => validateBmInputWithSchema({
+            input: data,
+            schema: snippetZodSchemaInsert,
+            stage,
+            operation: 'SnippetService::create.snippetZodSchemaInsert',
+            field: 'data',
+        })), Effect.flatMap((data) => this.snippetRepository.create(data).pipe(Effect.mapError(mapDbError({ stage, operation: 'create', factory: XfErrorFactory.createFailed })))));
+    }
+    listSnippets(filter = {}, options) {
+        const stage = 'SnippetService::listSnippets';
+        return pipe(validateInput(filter, 'filter', { stage }), Effect.flatMap((filter) => this.snippetRepository.find({ matchEq: filter, options }).pipe(Effect.mapError(mapDbError({ stage, operation: 'find', factory: XfErrorFactory.notFound })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in listSnippets');
+        })));
+    }
+    updateSnippet(id, patch) {
+        const stage = 'SnippetService::updateSnippet';
+        if (!patch || Object.keys(patch).length === 0) {
+            return Effect.fail(XfErrorFactory.inputRequired({ field: 'patch', stage }));
+        }
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((entityId) => validateBmInputWithSchema({
+            input: patch,
+            schema: snippetZodSchemaInsert.partial().strict(),
+            stage,
+            operation: 'SnippetService::updateSnippet.snippetZodSchemaInsert.patch',
+            field: 'patch',
+        }).pipe(Effect.map(() => entityId))), Effect.flatMap((entityId) => this.snippetRepository.patchById(entityId, patch).pipe(Effect.mapError(mapDbError({ stage, operation: 'patchById', factory: XfErrorFactory.upsertFailed })))), Effect.tapError((e) => Effect.sync(() => {
+            const info = effectErrorInfo(e);
+            this.logger?.error({ error: info.unwrapped, stage }, 'Error in updateSnippet');
+        })));
+    }
+    removeSnippet(id) {
+        const stage = 'SnippetService::removeSnippet';
+        return pipe(validateInput(id, 'id', { stage }), Effect.flatMap((entityId) => this.snippetRepository.deleteById(entityId).pipe(Effect.mapError(mapDbError({ stage, operation: 'deleteById', factory: XfErrorFactory.upsertFailed })))), Effect.map(() => undefined));
+    }
+}

package/dist/application/services/service.zod-validation.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from 'effect';
+import { type XfValidationError } from '@aopslab/xf-core';
+import type { ZodTypeAny } from 'zod';
+export type ValidateBmInputWithSchemaOptions<TInput> = {
+    input: TInput;
+    schema: ZodTypeAny;
+    stage: string;
+    operation: string;
+    field: string;
+};
+export declare const validateBmInputWithSchema: <TInput>({ input, schema, stage, operation, field, }: ValidateBmInputWithSchemaOptions<TInput>) => Effect.Effect<TInput, XfValidationError>;

package/dist/application/services/service.zod-validation.js

@@ -0,0 +1,14 @@
+import { Effect } from 'effect';
+import { XfErrorFactory } from '@aopslab/xf-core';
+import { zodErrorToXfResultLegacy } from '@aopslab/xf-validation';
+export const validateBmInputWithSchema = ({ input, schema, stage, operation, field, }) => {
+    const validation = schema.safeParse(input);
+    if (validation.success) {
+        return Effect.succeed(input);
+    }
+    return Effect.fail(XfErrorFactory.xfValidationFailed(zodErrorToXfResultLegacy(validation.error, stage), {
+        stage,
+        operation,
+        message: `Validation failed for ${field}`,
+    }, input));
+};

package/dist/domain/domain.d.ts

@@ -0,0 +1,8 @@
+export declare enum ErrorDomain {
+    Domain = "DOMAIN-DM"
+}
+export declare const DomainMetadata: {
+    readonly name: "Domain";
+    readonly version: "1.0.0";
+    readonly description: "Generated domain";
+};

package/dist/domain/domain.js

@@ -0,0 +1,9 @@
+export var ErrorDomain;
+(function (ErrorDomain) {
+    ErrorDomain["Domain"] = "DOMAIN-DM";
+})(ErrorDomain || (ErrorDomain = {}));
+export const DomainMetadata = {
+    name: 'Domain',
+    version: '1.0.0',
+    description: 'Generated domain',
+};

package/dist/domain/dto/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/domain/dto/index.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './dto/index.js';
+export * from './models/index.js';
+export * from './domain.js';

package/dist/domain/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './dto/index.js';
+export * from './models/index.js';
+export * from './domain.js';

package/dist/domain/models/asset/IbmAsset.d.ts

@@ -0,0 +1,5 @@
+import z from 'zod';
+import { assetZodSchema, assetZodSchemaInsert } from './zod.schema.js';
+export type IbmAsset = z.infer<typeof assetZodSchema>;
+export type IbmAssetInsert = z.infer<typeof assetZodSchemaInsert>;
+export declare const ibmAssetKeys: readonly ["id", "tenantId", "createdAt", "updatedAt", "scopeId", "assetUid", "kind", "title", "slug", "altText", "currentVersionId", "meta", "createdBy", "updatedBy"];

package/dist/domain/models/asset/IbmAsset.js

@@ -0,0 +1,18 @@
+export const ibmAssetKeys = [
+    'id',
+    'tenantId',
+    'createdAt',
+    'updatedAt',
+    'scopeId',
+    'assetUid',
+    'kind',
+    'title',
+    'slug',
+    'altText',
+    'currentVersionId',
+    'meta',
+    'createdBy',
+    'updatedBy',
+];
+const _verifyKeys = true;
+void _verifyKeys;

package/dist/domain/models/asset/index.d.ts

@@ -0,0 +1,2 @@
+export * from './zod.schema.js';
+export * from './IbmAsset.js';

package/dist/domain/models/asset/index.js

@@ -0,0 +1,2 @@
+export * from './zod.schema.js';
+export * from './IbmAsset.js';

package/dist/domain/models/asset/zod.schema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const assetZodSchema: z.ZodObject<{
+    scopeId: z.ZodString;
+    assetUid: z.ZodString;
+    kind: z.ZodEnum<{
+        file: "file";
+        document: "document";
+        image: "image";
+        attachment: "attachment";
+    }>;
+    title: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    altText: z.ZodOptional<z.ZodString>;
+    currentVersionId: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodUnknown>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    updatedBy: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>, z.ZodTransform<Date, string | Date>>>;
+    updatedAt: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>, z.ZodTransform<Date, string | Date>>>;
+    id: z.ZodOptional<z.ZodString>;
+    tenantId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const assetZodSchemaInsert: z.ZodObject<{
+    scopeId: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodUnknown>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    updatedBy: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        file: "file";
+        document: "document";
+        image: "image";
+        attachment: "attachment";
+    }>;
+    assetUid: z.ZodString;
+    altText: z.ZodOptional<z.ZodString>;
+    currentVersionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;

package/dist/domain/models/asset/zod.schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { IbmZodSchema } from '@aopslab/xf-bm';
+export const assetZodSchema = z
+    .object({
+    ...IbmZodSchema.shape,
+    scopeId: z.string(),
+    assetUid: z.string(),
+    kind: z.enum(['image', 'file', 'document', 'attachment']),
+    title: z.string().optional(),
+    slug: z.string().optional(),
+    altText: z.string().optional(),
+    currentVersionId: z.string().uuid().optional(),
+    meta: z.unknown().optional(),
+    createdBy: z.string().optional(),
+    updatedBy: z.string().optional(),
+});
+export const assetZodSchemaInsert = assetZodSchema.omit({
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+    tenantId: true,
+}).strict();

package/dist/domain/models/assetVersion/IbmAssetVersion.d.ts

@@ -0,0 +1,6 @@
+import z from 'zod';
+import { assetVersionMutablePatchZodSchema, assetVersionZodSchema, assetVersionZodSchemaInsert } from './zod.schema.js';
+export type IbmAssetVersion = z.infer<typeof assetVersionZodSchema>;
+export type IbmAssetVersionInsert = z.infer<typeof assetVersionZodSchemaInsert>;
+export type IbmAssetVersionPatch = z.infer<typeof assetVersionMutablePatchZodSchema>;
+export declare const ibmAssetVersionKeys: readonly ["id", "tenantId", "createdAt", "updatedAt", "assetId", "version", "label", "status", "storageKey", "sourcePath", "sourceUrl", "filename", "mime", "contentHash", "byteSize", "width", "height", "variants", "meta", "createdBy", "updatedBy"];

package/dist/domain/models/assetVersion/IbmAssetVersion.js

@@ -0,0 +1,25 @@
+export const ibmAssetVersionKeys = [
+    'id',
+    'tenantId',
+    'createdAt',
+    'updatedAt',
+    'assetId',
+    'version',
+    'label',
+    'status',
+    'storageKey',
+    'sourcePath',
+    'sourceUrl',
+    'filename',
+    'mime',
+    'contentHash',
+    'byteSize',
+    'width',
+    'height',
+    'variants',
+    'meta',
+    'createdBy',
+    'updatedBy',
+];
+const _verifyKeys = true;
+void _verifyKeys;

package/dist/domain/models/assetVersion/index.d.ts

@@ -0,0 +1,2 @@
+export * from './zod.schema.js';
+export * from './IbmAssetVersion.js';

package/dist/domain/models/assetVersion/index.js

@@ -0,0 +1,2 @@
+export * from './zod.schema.js';
+export * from './IbmAssetVersion.js';

package/dist/domain/models/assetVersion/zod.schema.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+export declare const assetVersionStatusZodSchema: z.ZodEnum<{
+    draft: "draft";
+    archived: "archived";
+    ready: "ready";
+    failed: "failed";
+}>;
+export declare const assetVersionZodSchema: z.ZodObject<{
+    assetId: z.ZodString;
+    version: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        draft: "draft";
+        archived: "archived";
+        ready: "ready";
+        failed: "failed";
+    }>;
+    storageKey: z.ZodOptional<z.ZodString>;
+    sourcePath: z.ZodOptional<z.ZodString>;
+    sourceUrl: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    mime: z.ZodString;
+    contentHash: z.ZodString;
+    byteSize: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    variants: z.ZodOptional<z.ZodUnknown>;
+    meta: z.ZodOptional<z.ZodUnknown>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    updatedBy: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>, z.ZodTransform<Date, string | Date>>>;
+    updatedAt: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>, z.ZodTransform<Date, string | Date>>>;
+    id: z.ZodOptional<z.ZodString>;
+    tenantId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const assetVersionZodSchemaInsert: z.ZodObject<{
+    status: z.ZodEnum<{
+        draft: "draft";
+        archived: "archived";
+        ready: "ready";
+        failed: "failed";
+    }>;
+    meta: z.ZodOptional<z.ZodUnknown>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    updatedBy: z.ZodOptional<z.ZodString>;
+    version: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    assetId: z.ZodString;
+    storageKey: z.ZodOptional<z.ZodString>;
+    sourcePath: z.ZodOptional<z.ZodString>;
+    sourceUrl: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    mime: z.ZodString;
+    contentHash: z.ZodString;
+    byteSize: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    variants: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const assetVersionMutablePatchZodSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        archived: "archived";
+        ready: "ready";
+        failed: "failed";
+    }>>;
+    variants: z.ZodOptional<z.ZodUnknown>;
+    meta: z.ZodOptional<z.ZodUnknown>;
+    updatedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;

package/dist/domain/models/assetVersion/zod.schema.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { IbmZodSchema } from '@aopslab/xf-bm';
+export const assetVersionStatusZodSchema = z.enum(['draft', 'ready', 'archived', 'failed']);
+export const assetVersionZodSchema = z
+    .object({
+    ...IbmZodSchema.shape,
+    assetId: z.string().uuid(),
+    version: z.number().int(),
+    label: z.string().optional(),
+    status: assetVersionStatusZodSchema,
+    storageKey: z.string().optional(),
+    sourcePath: z.string().optional(),
+    sourceUrl: z.string().optional(),
+    filename: z.string().optional(),
+    mime: z.string(),
+    contentHash: z.string(),
+    byteSize: z.number().int().nonnegative().optional(),
+    width: z.number().int().nonnegative().optional(),
+    height: z.number().int().nonnegative().optional(),
+    variants: z.unknown().optional(),
+    meta: z.unknown().optional(),
+    createdBy: z.string().optional(),
+    updatedBy: z.string().optional(),
+});
+export const assetVersionZodSchemaInsert = assetVersionZodSchema.omit({
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+    tenantId: true,
+}).strict();
+export const assetVersionMutablePatchZodSchema = z.object({
+    label: z.string().optional(),
+    status: assetVersionStatusZodSchema.optional(),
+    variants: z.unknown().optional(),
+    meta: z.unknown().optional(),
+    updatedBy: z.string().optional(),
+}).strict();

package/dist/domain/models/document/IbmDocument.d.ts

@@ -0,0 +1,8 @@
+import z from 'zod';
+import { DotNestedMlgKeys } from '@aopslab/xf-bm';
+import { documentZodSchema, documentZodSchemaInsert } from './zod.schema.js';
+export type IbmDocument = z.infer<typeof documentZodSchema>;
+export type IbmDocumentInsert = z.infer<typeof documentZodSchemaInsert>;
+export declare const ibmDocumentKeys: readonly ["id", "tenantId", "createdAt", "updatedAt", "scopeId", "documentUid", "groupId", "groupUid", "slug", "title", "titleMl", "summary", "summaryMl", "description", "descriptionMl", "status", "visibility", "tags", "pageSize", "meta", "createdBy", "updatedBy"];
+export type BmDocumentMlgKeys = DotNestedMlgKeys<IbmDocument>;
+export declare const bmDocumentMlgFields: ("titleMl" | "summaryMl" | "descriptionMl" | "meta")[];

package/dist/domain/models/document/IbmDocument.js

@@ -0,0 +1,30 @@
+import { mlgFieldsOf } from '@aopslab/xf-bm';
+export const ibmDocumentKeys = [
+    'id',
+    'tenantId',
+    'createdAt',
+    'updatedAt',
+    'scopeId',
+    'documentUid',
+    'groupId',
+    'groupUid',
+    'slug',
+    'title',
+    'titleMl',
+    'summary',
+    'summaryMl',
+    'description',
+    'descriptionMl',
+    'status',
+    'visibility',
+    'tags',
+    'pageSize',
+    'meta',
+    'createdBy',
+    'updatedBy',
+];
+const _verifyKeys = true;
+void _verifyKeys;
+export const bmDocumentMlgFields = mlgFieldsOf()('titleMl', 'summaryMl', 'descriptionMl', 'meta');
+const _verifyMlgFields = true;
+void _verifyMlgFields;

package/dist/domain/models/document/index.d.ts

@@ -0,0 +1,2 @@
+export * from './zod.schema.js';
+export * from './IbmDocument.js';

package/dist/domain/models/document/index.js

@@ -0,0 +1,2 @@
+export * from './zod.schema.js';
+export * from './IbmDocument.js';