@remit/data-ports 0.0.82 → 0.0.84

package/dist/account-settings.d.ts

@@ -0,0 +1,371 @@
+import { AccountSettingName } from "@remit/domain-enums";
+import { z } from "zod";
+export type AccountSettingNameValue = (typeof AccountSettingName)[keyof typeof AccountSettingName];
+/**
+ * Per-`kind` value schemas, one per variant of the `AccountSettingValue`
+ * discriminated union in TypeSpec (`AccountSetting.tsp`). Authored here because
+ * the registry is the binding authority for what a value must satisfy — these
+ * are the contract every read and write is validated against.
+ */
+export declare const BooleanSettingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"Boolean">;
+    value: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    kind: "Boolean";
+    value: boolean;
+}, {
+    kind: "Boolean";
+    value: boolean;
+}>;
+export declare const StringSettingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"String">;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "String";
+    value: string;
+}, {
+    kind: "String";
+    value: string;
+}>;
+export declare const NumberSettingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"Number">;
+    value: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "Number";
+    value: number;
+}, {
+    kind: "Number";
+    value: number;
+}>;
+export declare const StringListSettingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"StringList">;
+    value: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    kind: "StringList";
+    value: string[];
+}, {
+    kind: "StringList";
+    value: string[];
+}>;
+export declare const MapSettingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"Map">;
+    value: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "Map";
+    value: Record<string, string>;
+}, {
+    kind: "Map";
+    value: Record<string, string>;
+}>;
+/**
+ * MutedFlag-valued setting. The value is a rich mute object (`MutedFlag` in
+ * TypeSpec / `@remit/api-openapi-types`): a boolean plus audit metadata. The
+ * schema is authored here — generated packages ship only `.d.ts` for this shape,
+ * so the registry owns the runtime contract a relocated mute flag is validated
+ * against (RFC 032 lesson from the signature slice).
+ */
+export declare const MutedFlagSettingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"MutedFlag">;
+    value: z.ZodObject<{
+        value: z.ZodBoolean;
+        setAt: z.ZodNumber;
+        setBy: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        value: boolean;
+        setAt: number;
+        setBy?: string | undefined;
+        expiresAt?: number | undefined;
+        reason?: string | undefined;
+    }, {
+        value: boolean;
+        setAt: number;
+        setBy?: string | undefined;
+        expiresAt?: number | undefined;
+        reason?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    kind: "MutedFlag";
+    value: {
+        value: boolean;
+        setAt: number;
+        setBy?: string | undefined;
+        expiresAt?: number | undefined;
+        reason?: string | undefined;
+    };
+}, {
+    kind: "MutedFlag";
+    value: {
+        value: boolean;
+        setAt: number;
+        setBy?: string | undefined;
+        expiresAt?: number | undefined;
+        reason?: string | undefined;
+    };
+}>;
+/**
+ * RFC 032 Tier 1 registry: binds each setting `name` to the zod schema its
+ * `value` must satisfy. The discriminated union (`kind`) types the shape on the
+ * wire; this registry binds a name to one concrete shape, so a read or write of
+ * a given setting is validated against exactly the variant it requires.
+ *
+ * Adding a setting key is a deliberate change: extend the `AccountSettingName`
+ * enum in TypeSpec and add an entry here — never an ad-hoc, unvalidated value.
+ */
+export declare const accountSettingRegistry: {
+    readonly Theme: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+    readonly Density: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+    readonly DefaultComposerFormat: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+    readonly PinnedFolders: z.ZodObject<{
+        kind: z.ZodLiteral<"StringList">;
+        value: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "StringList";
+        value: string[];
+    }, {
+        kind: "StringList";
+        value: string[];
+    }>;
+    readonly AccountSignaturePlainText: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+    readonly AccountSignatureHtml: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+    readonly AccountDisplayName: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+    readonly AccountMuted: z.ZodObject<{
+        kind: z.ZodLiteral<"MutedFlag">;
+        value: z.ZodObject<{
+            value: z.ZodBoolean;
+            setAt: z.ZodNumber;
+            setBy: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            value: boolean;
+            setAt: number;
+            setBy?: string | undefined;
+            expiresAt?: number | undefined;
+            reason?: string | undefined;
+        }, {
+            value: boolean;
+            setAt: number;
+            setBy?: string | undefined;
+            expiresAt?: number | undefined;
+            reason?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "MutedFlag";
+        value: {
+            value: boolean;
+            setAt: number;
+            setBy?: string | undefined;
+            expiresAt?: number | undefined;
+            reason?: string | undefined;
+        };
+    }, {
+        kind: "MutedFlag";
+        value: {
+            value: boolean;
+            setAt: number;
+            setBy?: string | undefined;
+            expiresAt?: number | undefined;
+            reason?: string | undefined;
+        };
+    }>;
+    readonly AccountComposeLanguages: z.ZodObject<{
+        kind: z.ZodLiteral<"StringList">;
+        value: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "StringList";
+        value: string[];
+    }, {
+        kind: "StringList";
+        value: string[];
+    }>;
+    readonly MailboxDisplayName: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+    readonly MailboxMuted: z.ZodObject<{
+        kind: z.ZodLiteral<"MutedFlag">;
+        value: z.ZodObject<{
+            value: z.ZodBoolean;
+            setAt: z.ZodNumber;
+            setBy: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodOptional<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            value: boolean;
+            setAt: number;
+            setBy?: string | undefined;
+            expiresAt?: number | undefined;
+            reason?: string | undefined;
+        }, {
+            value: boolean;
+            setAt: number;
+            setBy?: string | undefined;
+            expiresAt?: number | undefined;
+            reason?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "MutedFlag";
+        value: {
+            value: boolean;
+            setAt: number;
+            setBy?: string | undefined;
+            expiresAt?: number | undefined;
+            reason?: string | undefined;
+        };
+    }, {
+        kind: "MutedFlag";
+        value: {
+            value: boolean;
+            setAt: number;
+            setBy?: string | undefined;
+            expiresAt?: number | undefined;
+            reason?: string | undefined;
+        };
+    }>;
+    readonly FolderRoleAppointment: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+    readonly FolderRoleAppointmentLabel: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+    /**
+     * Deprecated tombstone: superseded by `FolderRoleAppointment` (RFC 032
+     * exclusive-folder-appointment, #976). Kept only so `baseSettingName`
+     * recognises leftover `MailboxRole#<mailboxId>` rows written by the #963/#964
+     * backfill instead of throwing `Unknown account setting name`; the read-side
+     * groupers (`groupAccountOverrides`, `groupMailboxOverrides`,
+     * `groupFolderAppointmentsByAccount`) already skip any base they don't
+     * explicitly handle, so a `MailboxRole` row is ignored, not surfaced. Do not
+     * write new rows under this name. Remove once the row-deletion migration ships.
+     */
+    readonly MailboxRole: z.ZodObject<{
+        kind: z.ZodLiteral<"String">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "String";
+        value: string;
+    }, {
+        kind: "String";
+        value: string;
+    }>;
+};
+export type AccountSettingRegistry = typeof accountSettingRegistry;
+export type AccountSettingValueFor<N extends AccountSettingNameValue> = z.infer<AccountSettingRegistry[N]>;
+/**
+ * Separator between a setting's base enum member and its per-target suffix in a
+ * composite stored name (e.g. `AccountSignaturePlainText#<accountId>`). Some
+ * settings are per-account, but `AccountSetting` is keyed per accountConfigId, so
+ * the stored `name` encodes the target after this separator. The registry still
+ * validates by the base member; readers filter by the suffix.
+ */
+export declare const SETTING_NAME_SEPARATOR = "#";
+/**
+ * A persisted setting `name`. Either a plain closed-enum member or a composite
+ * `<base>#<suffix>` for a per-target setting. Always a `string` whose first
+ * segment is a known base member.
+ */
+export type StoredSettingName = string;
+/** Compose the stored name for a per-target setting (e.g. one signature per account). */
+export declare function composeSettingName(base: AccountSettingNameValue, target: string): StoredSettingName;
+/**
+ * Derive the base enum member from a stored name. Strips the `#<suffix>` from a
+ * composite name; returns a plain name unchanged. Throws when the base segment
+ * is not a registered setting (let-it-crash — an unknown key is a programmer
+ * error, never an ad-hoc column).
+ */
+export declare function baseSettingName(name: StoredSettingName): AccountSettingNameValue;
+/**
+ * Every value shape the registry can hold. Useful where a value is handled
+ * generically (e.g. the persisted `value` attribute) rather than per-name.
+ */
+export type AnyAccountSettingValue = z.infer<typeof BooleanSettingSchema | typeof StringSettingSchema | typeof NumberSettingSchema | typeof StringListSettingSchema | typeof MapSettingSchema | typeof MutedFlagSettingSchema>;
+/**
+ * Parse-and-narrow a value against the schema registered for `name`. Accepts a
+ * plain enum member or a composite `<base>#<suffix>` name; validation resolves
+ * to the base member's schema. Throws a ZodError on mismatch (let-it-crash);
+ * returns the value typed to the variant the name requires.
+ */
+export declare function parseAccountSettingValue<N extends AccountSettingNameValue>(name: N, value: unknown): AccountSettingValueFor<N>;
+export declare function parseAccountSettingValue(name: StoredSettingName, value: unknown): AnyAccountSettingValue;
+/**
+ * Non-throwing variant: returns the zod SafeParse result so a caller with a
+ * recovery path can branch on `success`. Accepts composite names like above.
+ */
+export declare function safeParseAccountSettingValue<N extends AccountSettingNameValue>(name: N, value: unknown): z.SafeParseReturnType<unknown, AccountSettingValueFor<N>>;
+export declare function safeParseAccountSettingValue(name: StoredSettingName, value: unknown): z.SafeParseReturnType<unknown, AnyAccountSettingValue>;

package/dist/account-settings.js

@@ -0,0 +1,114 @@
+import { AccountSettingName } from "@remit/domain-enums";
+import { z } from "zod";
+/**
+ * Per-`kind` value schemas, one per variant of the `AccountSettingValue`
+ * discriminated union in TypeSpec (`AccountSetting.tsp`). Authored here because
+ * the registry is the binding authority for what a value must satisfy — these
+ * are the contract every read and write is validated against.
+ */
+export const BooleanSettingSchema = z.object({
+    kind: z.literal("Boolean"),
+    value: z.boolean(),
+});
+export const StringSettingSchema = z.object({
+    kind: z.literal("String"),
+    value: z.string(),
+});
+export const NumberSettingSchema = z.object({
+    kind: z.literal("Number"),
+    value: z.number(),
+});
+export const StringListSettingSchema = z.object({
+    kind: z.literal("StringList"),
+    value: z.array(z.string()),
+});
+export const MapSettingSchema = z.object({
+    kind: z.literal("Map"),
+    value: z.record(z.string(), z.string()),
+});
+/**
+ * MutedFlag-valued setting. The value is a rich mute object (`MutedFlag` in
+ * TypeSpec / `@remit/api-openapi-types`): a boolean plus audit metadata. The
+ * schema is authored here — generated packages ship only `.d.ts` for this shape,
+ * so the registry owns the runtime contract a relocated mute flag is validated
+ * against (RFC 032 lesson from the signature slice).
+ */
+export const MutedFlagSettingSchema = z.object({
+    kind: z.literal("MutedFlag"),
+    value: z.object({
+        value: z.boolean(),
+        setAt: z.number(),
+        setBy: z.string().optional(),
+        expiresAt: z.number().optional(),
+        reason: z.string().optional(),
+    }),
+});
+/**
+ * RFC 032 Tier 1 registry: binds each setting `name` to the zod schema its
+ * `value` must satisfy. The discriminated union (`kind`) types the shape on the
+ * wire; this registry binds a name to one concrete shape, so a read or write of
+ * a given setting is validated against exactly the variant it requires.
+ *
+ * Adding a setting key is a deliberate change: extend the `AccountSettingName`
+ * enum in TypeSpec and add an entry here — never an ad-hoc, unvalidated value.
+ */
+export const accountSettingRegistry = {
+    [AccountSettingName.Theme]: StringSettingSchema,
+    [AccountSettingName.Density]: StringSettingSchema,
+    [AccountSettingName.DefaultComposerFormat]: StringSettingSchema,
+    [AccountSettingName.PinnedFolders]: StringListSettingSchema,
+    [AccountSettingName.AccountSignaturePlainText]: StringSettingSchema,
+    [AccountSettingName.AccountSignatureHtml]: StringSettingSchema,
+    [AccountSettingName.AccountDisplayName]: StringSettingSchema,
+    [AccountSettingName.AccountMuted]: MutedFlagSettingSchema,
+    [AccountSettingName.AccountComposeLanguages]: StringListSettingSchema,
+    [AccountSettingName.MailboxDisplayName]: StringSettingSchema,
+    [AccountSettingName.MailboxMuted]: MutedFlagSettingSchema,
+    [AccountSettingName.FolderRoleAppointment]: StringSettingSchema,
+    [AccountSettingName.FolderRoleAppointmentLabel]: StringSettingSchema,
+    /**
+     * Deprecated tombstone: superseded by `FolderRoleAppointment` (RFC 032
+     * exclusive-folder-appointment, #976). Kept only so `baseSettingName`
+     * recognises leftover `MailboxRole#<mailboxId>` rows written by the #963/#964
+     * backfill instead of throwing `Unknown account setting name`; the read-side
+     * groupers (`groupAccountOverrides`, `groupMailboxOverrides`,
+     * `groupFolderAppointmentsByAccount`) already skip any base they don't
+     * explicitly handle, so a `MailboxRole` row is ignored, not surfaced. Do not
+     * write new rows under this name. Remove once the row-deletion migration ships.
+     */
+    [AccountSettingName.MailboxRole]: StringSettingSchema,
+};
+/**
+ * Separator between a setting's base enum member and its per-target suffix in a
+ * composite stored name (e.g. `AccountSignaturePlainText#<accountId>`). Some
+ * settings are per-account, but `AccountSetting` is keyed per accountConfigId, so
+ * the stored `name` encodes the target after this separator. The registry still
+ * validates by the base member; readers filter by the suffix.
+ */
+export const SETTING_NAME_SEPARATOR = "#";
+/** Compose the stored name for a per-target setting (e.g. one signature per account). */
+export function composeSettingName(base, target) {
+    return `${base}${SETTING_NAME_SEPARATOR}${target}`;
+}
+const isAccountSettingNameValue = (value) => Object.hasOwn(accountSettingRegistry, value);
+/**
+ * Derive the base enum member from a stored name. Strips the `#<suffix>` from a
+ * composite name; returns a plain name unchanged. Throws when the base segment
+ * is not a registered setting (let-it-crash — an unknown key is a programmer
+ * error, never an ad-hoc column).
+ */
+export function baseSettingName(name) {
+    const base = name.split(SETTING_NAME_SEPARATOR)[0] ?? "";
+    if (!isAccountSettingNameValue(base)) {
+        throw new Error(`Unknown account setting name: ${name}`);
+    }
+    return base;
+}
+export function parseAccountSettingValue(name, value) {
+    const schema = accountSettingRegistry[baseSettingName(name)];
+    return schema.parse(value);
+}
+export function safeParseAccountSettingValue(name, value) {
+    const schema = accountSettingRegistry[baseSettingName(name)];
+    return schema.safeParse(value);
+}

package/dist/conformance/account.d.ts

@@ -0,0 +1,3 @@
+import type { IAccountRepository } from "../interfaces/account.js";
+import type { RepositoryConformanceHarness } from "./harness.js";
+export declare function accountRepositoryConformance(harness: RepositoryConformanceHarness<IAccountRepository>): void;

package/dist/conformance/account.js

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { AccountAuthType, AccountService, ConnectionState, SyncPhase, } from "@remit/domain-enums";
+const accountInput = (accountConfigId) => ({
+    accountConfigId,
+    username: "person@example.com",
+    email: "person@example.com",
+    imapHost: "imap.example.com",
+    imapPort: 993,
+    imapTls: true,
+    imapStartTls: false,
+    isActive: true,
+    connectionState: ConnectionState.NotAuthenticated,
+});
+const everyUpdatableField = {
+    username: "renamed@example.org",
+    email: "renamed@example.org",
+    authType: AccountAuthType.OauthMicrosoft,
+    syncedServices: [AccountService.Calendar],
+    grantedScopes: ["https://outlook.office.com/SMTP.Send"],
+    passwordHash: "password-ciphertext",
+    oauthRefreshTokenHash: "refresh-token-ciphertext",
+    oauthTokenUpdatedAt: 1_700_000_000_001,
+    imapHost: "imap.example.org",
+    imapPort: 143,
+    imapTls: false,
+    imapStartTls: true,
+    smtpEnabled: true,
+    smtpHost: "smtp.example.org",
+    smtpPort: 465,
+    smtpTls: true,
+    smtpStartTls: true,
+    smtpUsername: "smtp-person",
+    smtpPasswordHash: "smtp-password-ciphertext",
+    isActive: false,
+    connectionState: ConnectionState.Authenticated,
+    deletedAt: 1_700_000_000_002,
+    lastConnectedAt: 1_700_000_000_003,
+    lastSyncAt: 1_700_000_000_004,
+    lastError: "refused",
+    syncPhase: SyncPhase.complete,
+    mailboxCountTotal: 7,
+    mailboxCountSynced: 3,
+};
+export function accountRepositoryConformance(harness) {
+    describe("IAccountRepository conformance", () => {
+        let repo;
+        before(async () => {
+            repo = await harness.createRepository();
+        });
+        after(() => harness.teardown());
+        test("an account created without a service selection syncs mail", async () => {
+            const created = await repo.create(accountInput(harness.makeId()));
+            assert.deepEqual(created.syncedServices, [AccountService.Mail]);
+            assert.deepEqual((await repo.get(created.accountId)).syncedServices, [
+                AccountService.Mail,
+            ]);
+        });
+        test("an account keeps the selection it was created with", async () => {
+            const created = await repo.create({
+                ...accountInput(harness.makeId()),
+                syncedServices: [AccountService.Calendar],
+            });
+            assert.deepEqual((await repo.get(created.accountId)).syncedServices, [
+                AccountService.Calendar,
+            ]);
+        });
+        test("an update replaces the selection outright", async () => {
+            const created = await repo.create(accountInput(harness.makeId()));
+            const updated = await repo.update(created.accountId, {
+                syncedServices: [AccountService.Mail, AccountService.Calendar],
+            });
+            assert.deepEqual(updated.syncedServices, [
+                AccountService.Mail,
+                AccountService.Calendar,
+            ]);
+            assert.deepEqual((await repo.get(created.accountId)).syncedServices, [
+                AccountService.Mail,
+                AccountService.Calendar,
+            ]);
+        });
+        test("an update that leaves the selection out keeps it", async () => {
+            const created = await repo.create({
+                ...accountInput(harness.makeId()),
+                syncedServices: [AccountService.Calendar],
+            });
+            await repo.update(created.accountId, { lastError: "timeout" });
+            assert.deepEqual((await repo.get(created.accountId)).syncedServices, [
+                AccountService.Calendar,
+            ]);
+        });
+        test("the mail sources of a config leave out an account with mail off", async () => {
+            const accountConfigId = harness.makeId();
+            const mailOnly = await repo.create(accountInput(accountConfigId));
+            const both = await repo.create({
+                ...accountInput(accountConfigId),
+                syncedServices: [AccountService.Mail, AccountService.Calendar],
+            });
+            await repo.create({
+                ...accountInput(accountConfigId),
+                syncedServices: [AccountService.Calendar],
+            });
+            await repo.create(accountInput(harness.makeId()));
+            const sources = await repo.listMailSourcesByAccountConfig(accountConfigId);
+            assert.deepEqual(sources.map((account) => account.accountId).sort(), [mailOnly.accountId, both.accountId].sort());
+        });
+        test("an update stores every field it is handed", async () => {
+            const created = await repo.create(accountInput(harness.makeId()));
+            await repo.update(created.accountId, everyUpdatableField);
+            const stored = await repo.get(created.accountId);
+            assert.deepEqual(stored, {
+                ...created,
+                ...everyUpdatableField,
+                updatedAt: stored.updatedAt,
+            });
+        });
+    });
+}

package/dist/conformance/calendar-collection.d.ts

@@ -0,0 +1,3 @@
+import type { ICalendarCollectionRepository } from "../interfaces/calendar-collection.js";
+import type { RepositoryConformanceHarness } from "./harness.js";
+export declare function calendarCollectionRepositoryConformance(harness: RepositoryConformanceHarness<ICalendarCollectionRepository>): void;