@marcoappio/marco-config 2.0.573 → 2.0.574

package/dist/appwrite/appwrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appwrite.d.ts","sourceRoot":"","sources":["../../src/appwrite/appwrite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAgE5B,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoLN,CAAA;AAEV,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYX,CAAA;AAEV,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,UAAU,CAAA;AACtD,MAAM,MAAM,WAAW,CAAC,MAAM,SAAS,gBAAgB,IAAI,CAAC,CAAC,WAAW,CAAC,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA"}

package/dist/appwrite/appwrite.js

@@ -0,0 +1,246 @@
+import * as v from 'valibot';
+const identifierSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(255));
+const appwriteRowIdSchema = v.pipe(v.string(), v.minLength(1), v.maxLength(36), v.regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/));
+const timestampSchema = v.pipe(v.string(), v.isoTimestamp());
+const nonNegativeIntegerSchema = v.pipe(v.number(), v.integer(), v.minValue(0));
+const colourSchema = v.pipe(v.string(), v.maxLength(64));
+const emailSchema = v.pipe(v.string(), v.email());
+const jsonArrayTextSchema = v.pipe(v.string(), v.parseJson(), v.array(v.unknown()));
+const jsonObjectTextSchema = v.pipe(v.string(), v.parseJson(), v.check(value => !Array.isArray(value)), v.looseObject({}));
+const accountProviders = ['GMAIL', 'OUTLOOK', 'IMAP'];
+const accountStates = ['AWAITING_CONNECTION', 'CONNECTED', 'ERROR', 'DISCONNECTED'];
+const commandStates = ['ACCEPTED', 'RUNNING', 'SUCCEEDED', 'FAILED'];
+const draftStates = ['DRAFT', 'SCHEDULED', 'SENDING', 'SENT', 'FAILED', 'CANCELLED'];
+const draftTypes = ['COMPOSE', 'REPLY', 'FORWARD'];
+const jobStates = ['PENDING', 'RUNNING', 'SUCCEEDED', 'FAILED', 'CANCELLED'];
+const labelSpecialUses = ['ALL', 'ARCHIVE', 'DRAFTS', 'INBOX', 'JUNK', 'SENT', 'STARRED', 'TRASH'];
+const mailboxSyncStates = ['INITIAL', 'SYNCING', 'IDLE', 'ERROR'];
+const watcherShardStates = ['ACTIVE', 'IDLE', 'STOPPED', 'FAILED'];
+const appwriteIds = {
+    bucket: 'marco-files',
+    database: 'marco',
+    functions: {
+        api: 'marco-api',
+        worker: 'marco-worker',
+    },
+    tables: {
+        accounts: 'accounts',
+        aliases: 'aliases',
+        commands: 'commands',
+        contacts: 'contacts',
+        credentials: 'credentials',
+        drafts: 'drafts',
+        jobs: 'jobs',
+        labels: 'labels',
+        mailboxSyncStates: 'mailbox_sync_states',
+        messages: 'messages',
+        profiles: 'profiles',
+        pushNotificationTokens: 'push_notification_tokens',
+        savedViews: 'saved_views',
+        threads: 'threads',
+        watcherShards: 'watcher_shards',
+    },
+};
+const wireMetadata = (tableId) => ({
+    $createdAt: timestampSchema,
+    $databaseId: v.literal(appwriteIds.database),
+    $id: appwriteRowIdSchema,
+    $permissions: v.array(v.string()),
+    $sequence: nonNegativeIntegerSchema,
+    $tableId: v.literal(tableId),
+    $updatedAt: timestampSchema,
+});
+const rowSchemas = {
+    accounts: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.accounts),
+        colour: colourSchema,
+        displayName: v.optional(identifierSchema),
+        initialSyncCompletedAt: v.optional(timestampSchema),
+        lastErrorCode: v.optional(identifierSchema),
+        lastSuccessfulSyncAt: v.optional(timestampSchema),
+        mailProcessedCount: nonNegativeIntegerSchema,
+        mailTotalCount: nonNegativeIntegerSchema,
+        primaryAliasId: v.optional(identifierSchema),
+        primaryEmail: emailSchema,
+        provider: v.picklist(accountProviders),
+        state: v.picklist(accountStates),
+        userId: identifierSchema,
+        watcherShardId: v.optional(identifierSchema),
+    }),
+    aliases: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.aliases),
+        accountId: identifierSchema,
+        email: emailSchema,
+        isPrimary: v.boolean(),
+        name: v.optional(identifierSchema),
+        providerId: identifierSchema,
+        signature: v.optional(v.string()),
+        userId: identifierSchema,
+    }),
+    commands: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.commands),
+        accountId: v.nullable(identifierSchema),
+        attempts: nonNegativeIntegerSchema,
+        canonicalRevision: v.nullable(nonNegativeIntegerSchema),
+        errorCode: v.nullable(identifierSchema),
+        kind: identifierSchema,
+        payload: v.string(),
+        payloadHash: identifierSchema,
+        state: v.picklist(commandStates),
+        submittedAt: timestampSchema,
+        userId: identifierSchema,
+    }),
+    contacts: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.contacts),
+        displayName: v.optional(identifierSchema),
+        lastContactedAt: v.optional(timestampSchema),
+        messageCount: nonNegativeIntegerSchema,
+        normalisedAddress: emailSchema,
+        searchText: v.string(),
+        userId: identifierSchema,
+    }),
+    credentials: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.credentials),
+        encryptedPayload: v.string(),
+        expiresAt: v.optional(timestampSchema),
+        provider: v.picklist(accountProviders),
+        userId: identifierSchema,
+    }),
+    drafts: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.drafts),
+        accountId: identifierSchema,
+        attachmentMetadata: v.string(),
+        contentHash: identifierSchema,
+        envelope: v.string(),
+        errorCode: v.nullable(identifierSchema),
+        fromAliasId: v.nullable(identifierSchema),
+        html: v.string(),
+        referencedMessageId: v.nullable(identifierSchema),
+        revision: nonNegativeIntegerSchema,
+        scheduledAt: v.nullable(timestampSchema),
+        sequence: nonNegativeIntegerSchema,
+        status: v.picklist(draftStates),
+        type: v.picklist(draftTypes),
+        userId: identifierSchema,
+    }),
+    jobs: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.jobs),
+        accountId: v.nullable(identifierSchema),
+        attempts: nonNegativeIntegerSchema,
+        commandId: identifierSchema,
+        dedupeKey: identifierSchema,
+        errorCode: v.nullable(identifierSchema),
+        kind: identifierSchema,
+        leaseExpiresAt: v.nullable(timestampSchema),
+        leaseId: v.nullable(identifierSchema),
+        maxAttempts: nonNegativeIntegerSchema,
+        nextRunAt: timestampSchema,
+        payload: v.string(),
+        state: v.picklist(jobStates),
+        userId: identifierSchema,
+    }),
+    labels: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.labels),
+        accountId: identifierSchema,
+        path: identifierSchema,
+        providerId: identifierSchema,
+        specialUse: v.nullable(v.picklist(labelSpecialUses)),
+        totalCount: nonNegativeIntegerSchema,
+        unreadCount: nonNegativeIntegerSchema,
+        userId: identifierSchema,
+    }),
+    mailboxSyncStates: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.mailboxSyncStates),
+        errorCode: v.nullable(identifierSchema),
+        lastEventAt: v.nullable(timestampSchema),
+        lastSyncAt: v.nullable(timestampSchema),
+        nextPollAt: v.nullable(timestampSchema),
+        provider: v.picklist(accountProviders),
+        providerCursor: v.nullable(v.string()),
+        state: v.picklist(mailboxSyncStates),
+        uidValidity: v.nullable(v.string()),
+        userId: identifierSchema,
+    }),
+    messages: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.messages),
+        accountId: identifierSchema,
+        attachmentMetadata: v.string(),
+        htmlFileId: v.nullable(identifierSchema),
+        preview: v.string(),
+        providerId: identifierSchema,
+        rawFileId: v.nullable(identifierSchema),
+        receivedAt: v.nullable(timestampSchema),
+        recipients: v.string(),
+        revision: nonNegativeIntegerSchema,
+        rfcMessageId: v.nullable(identifierSchema),
+        sender: v.string(),
+        sentAt: timestampSchema,
+        size: nonNegativeIntegerSchema,
+        threadId: identifierSchema,
+        userId: identifierSchema,
+    }),
+    profiles: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.profiles),
+        email: emailSchema,
+        name: v.optional(identifierSchema),
+        onboardingState: v.optional(identifierSchema),
+        timezone: v.optional(identifierSchema),
+    }),
+    pushNotificationTokens: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.pushNotificationTokens),
+        token: identifierSchema,
+        userId: identifierSchema,
+    }),
+    savedViews: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.savedViews),
+        aliasEmails: v.array(emailSchema),
+        icon: v.optional(identifierSchema),
+        name: identifierSchema,
+    }),
+    threads: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.threads),
+        accountId: identifierSchema,
+        archived: v.boolean(),
+        flagged: v.boolean(),
+        hasAttachments: v.boolean(),
+        labelIds: v.array(identifierSchema),
+        latestMessageAt: timestampSchema,
+        latestMessageId: identifierSchema,
+        messageCount: nonNegativeIntegerSchema,
+        participants: v.string(),
+        preview: v.string(),
+        providerId: identifierSchema,
+        revision: nonNegativeIntegerSchema,
+        searchText: v.string(),
+        seen: v.boolean(),
+        snoozedUntil: v.nullable(timestampSchema),
+        spam: v.boolean(),
+        subject: v.nullable(v.string()),
+        trashed: v.boolean(),
+        userId: identifierSchema,
+    }),
+    watcherShards: v.strictObject({
+        ...wireMetadata(appwriteIds.tables.watcherShards),
+        accountIds: v.array(identifierSchema),
+        errorCode: v.nullable(identifierSchema),
+        generation: nonNegativeIntegerSchema,
+        heartbeatAt: v.nullable(timestampSchema),
+        lastHandoffAt: v.nullable(timestampSchema),
+        leaseExpiresAt: v.nullable(timestampSchema),
+        leaseId: v.nullable(identifierSchema),
+        state: v.picklist(watcherShardStates),
+    }),
+};
+export const appwrite = {
+    decodedSchemas: {
+        attachmentMetadata: jsonArrayTextSchema,
+        commandPayload: jsonObjectTextSchema,
+        draftEnvelope: jsonObjectTextSchema,
+        jobPayload: jsonObjectTextSchema,
+        messageRecipients: jsonArrayTextSchema,
+        messageSender: jsonObjectTextSchema,
+        threadParticipants: jsonArrayTextSchema,
+    },
+    ids: appwriteIds,
+    rowSchemas,
+};

package/dist/appwrite/appwrite.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=appwrite.test.d.ts.map

package/dist/appwrite/appwrite.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appwrite.test.d.ts","sourceRoot":"","sources":["../../src/appwrite/appwrite.test.ts"],"names":[],"mappings":""}

package/dist/appwrite/appwrite.test.js

@@ -0,0 +1,301 @@
+import { describe, expect, it } from 'bun:test';
+import * as v from 'valibot';
+import { appwrite } from './appwrite';
+const metadata = {
+    $createdAt: '2026-07-15T00:00:00.000Z',
+    $databaseId: 'marco',
+    $id: 'row-1',
+    $permissions: ['read("user:user-1")'],
+    $sequence: 1,
+    $updatedAt: '2026-07-15T00:00:00.000Z',
+};
+const validRows = {
+    accounts: {
+        ...metadata,
+        $tableId: 'accounts',
+        colour: '#000000',
+        mailProcessedCount: 0,
+        mailTotalCount: 0,
+        primaryEmail: 'marco@example.com',
+        provider: 'GMAIL',
+        state: 'CONNECTED',
+        userId: 'user-1',
+    },
+    aliases: {
+        ...metadata,
+        $tableId: 'aliases',
+        accountId: 'account-1',
+        email: 'marco@example.com',
+        isPrimary: true,
+        providerId: 'provider-1',
+        userId: 'user-1',
+    },
+    commands: {
+        ...metadata,
+        $tableId: 'commands',
+        accountId: null,
+        attempts: 0,
+        canonicalRevision: null,
+        errorCode: null,
+        kind: 'thread.archive',
+        payload: '{"threadId":"thread-1"}',
+        payloadHash: 'hash-1',
+        state: 'ACCEPTED',
+        submittedAt: '2026-07-15T00:00:00.000Z',
+        userId: 'user-1',
+    },
+    contacts: {
+        ...metadata,
+        $tableId: 'contacts',
+        messageCount: 0,
+        normalisedAddress: 'marco@example.com',
+        searchText: 'marco',
+        userId: 'user-1',
+    },
+    credentials: {
+        ...metadata,
+        $tableId: 'credentials',
+        encryptedPayload: 'encrypted-payload',
+        provider: 'GMAIL',
+        userId: 'user-1',
+    },
+    drafts: {
+        ...metadata,
+        $tableId: 'drafts',
+        accountId: 'account-1',
+        attachmentMetadata: '[]',
+        contentHash: 'hash-1',
+        envelope: '{"to":[]}',
+        errorCode: null,
+        fromAliasId: null,
+        html: '<p>Draft</p>',
+        referencedMessageId: null,
+        revision: 0,
+        scheduledAt: null,
+        sequence: 0,
+        status: 'DRAFT',
+        type: 'COMPOSE',
+        userId: 'user-1',
+    },
+    jobs: {
+        ...metadata,
+        $tableId: 'jobs',
+        accountId: null,
+        attempts: 0,
+        commandId: 'command-1',
+        dedupeKey: 'dedupe-1',
+        errorCode: null,
+        kind: 'thread.archive',
+        leaseExpiresAt: null,
+        leaseId: null,
+        maxAttempts: 3,
+        nextRunAt: '2026-07-15T00:00:00.000Z',
+        payload: '{"threadId":"thread-1"}',
+        state: 'PENDING',
+        userId: 'user-1',
+    },
+    labels: {
+        ...metadata,
+        $tableId: 'labels',
+        accountId: 'account-1',
+        path: 'Inbox',
+        providerId: 'provider-1',
+        specialUse: 'INBOX',
+        totalCount: 0,
+        unreadCount: 0,
+        userId: 'user-1',
+    },
+    mailboxSyncStates: {
+        ...metadata,
+        $tableId: 'mailbox_sync_states',
+        errorCode: null,
+        lastEventAt: null,
+        lastSyncAt: null,
+        nextPollAt: null,
+        provider: 'GMAIL',
+        providerCursor: null,
+        state: 'IDLE',
+        uidValidity: null,
+        userId: 'user-1',
+    },
+    messages: {
+        ...metadata,
+        $tableId: 'messages',
+        accountId: 'account-1',
+        attachmentMetadata: '[]',
+        htmlFileId: null,
+        preview: 'Preview',
+        providerId: 'provider-1',
+        rawFileId: null,
+        receivedAt: null,
+        recipients: '[]',
+        revision: 0,
+        rfcMessageId: null,
+        sender: '{"email":"marco@example.com"}',
+        sentAt: '2026-07-15T00:00:00.000Z',
+        size: 1,
+        threadId: 'thread-1',
+        userId: 'user-1',
+    },
+    profiles: {
+        ...metadata,
+        $tableId: 'profiles',
+        email: 'marco@example.com',
+    },
+    pushNotificationTokens: {
+        ...metadata,
+        $tableId: 'push_notification_tokens',
+        token: 'ExponentPushToken[token]',
+        userId: 'user-1',
+    },
+    savedViews: {
+        ...metadata,
+        $tableId: 'saved_views',
+        aliasEmails: ['marco@example.com'],
+        name: 'Unread',
+    },
+    threads: {
+        ...metadata,
+        $tableId: 'threads',
+        accountId: 'account-1',
+        archived: false,
+        flagged: false,
+        hasAttachments: false,
+        labelIds: ['label-1'],
+        latestMessageAt: '2026-07-15T00:00:00.000Z',
+        latestMessageId: 'message-1',
+        messageCount: 1,
+        participants: '[]',
+        preview: 'Preview',
+        providerId: 'provider-1',
+        revision: 0,
+        searchText: 'preview',
+        seen: true,
+        snoozedUntil: null,
+        spam: false,
+        subject: null,
+        trashed: false,
+        userId: 'user-1',
+    },
+    watcherShards: {
+        ...metadata,
+        $tableId: 'watcher_shards',
+        accountIds: ['account-1'],
+        errorCode: null,
+        generation: 1,
+        heartbeatAt: null,
+        lastHandoffAt: null,
+        leaseExpiresAt: null,
+        leaseId: null,
+        state: 'ACTIVE',
+    },
+};
+describe('appwrite', () => {
+    it('exports the approved resource identifiers', () => {
+        expect(appwrite.ids).toEqual({
+            bucket: 'marco-files',
+            database: 'marco',
+            functions: { api: 'marco-api', worker: 'marco-worker' },
+            tables: {
+                accounts: 'accounts',
+                aliases: 'aliases',
+                commands: 'commands',
+                contacts: 'contacts',
+                credentials: 'credentials',
+                drafts: 'drafts',
+                jobs: 'jobs',
+                labels: 'labels',
+                mailboxSyncStates: 'mailbox_sync_states',
+                messages: 'messages',
+                profiles: 'profiles',
+                pushNotificationTokens: 'push_notification_tokens',
+                savedViews: 'saved_views',
+                threads: 'threads',
+                watcherShards: 'watcher_shards',
+            },
+        });
+    });
+    const rowTestCases = Object.keys(validRows);
+    for (const table of rowTestCases) {
+        it(`accepts the ${table} wire row`, () => {
+            expect(v.safeParse(appwrite.rowSchemas[table], validRows[table]).success).toBe(true);
+        });
+        it(`rejects incomplete ${table} metadata`, () => {
+            const { $id: _, ...rowWithoutId } = validRows[table];
+            expect(v.safeParse(appwrite.rowSchemas[table], rowWithoutId).success).toBe(false);
+        });
+    }
+    const invalidAccountRows = [
+        { description: 'an unknown state', row: { ...validRows.accounts, state: 'UNKNOWN' } },
+        { description: 'an unknown database ID', row: { ...validRows.accounts, $databaseId: 'other' } },
+        { description: 'a leading separator in $id', row: { ...validRows.accounts, $id: '-row-1' } },
+        { description: 'an overlong $id', row: { ...validRows.accounts, $id: 'a'.repeat(37) } },
+    ];
+    for (const testCase of invalidAccountRows) {
+        it(`rejects ${testCase.description}`, () => {
+            expect(v.safeParse(appwrite.rowSchemas.accounts, testCase.row).success).toBe(false);
+        });
+    }
+    const jsonTextTestCases = [
+        {
+            expected: [],
+            invalidValue: '{}',
+            name: 'attachment metadata',
+            schema: appwrite.decodedSchemas.attachmentMetadata,
+            value: '[]',
+        },
+        {
+            expected: { threadId: 'thread-1' },
+            invalidValue: '[]',
+            name: 'command payload',
+            schema: appwrite.decodedSchemas.commandPayload,
+            value: '{"threadId":"thread-1"}',
+        },
+        {
+            expected: { to: [] },
+            invalidValue: '[]',
+            name: 'draft envelope',
+            schema: appwrite.decodedSchemas.draftEnvelope,
+            value: '{"to":[]}',
+        },
+        {
+            expected: { threadId: 'thread-1' },
+            invalidValue: '[]',
+            name: 'job payload',
+            schema: appwrite.decodedSchemas.jobPayload,
+            value: '{"threadId":"thread-1"}',
+        },
+        {
+            expected: [],
+            invalidValue: '{}',
+            name: 'message recipients',
+            schema: appwrite.decodedSchemas.messageRecipients,
+            value: '[]',
+        },
+        {
+            expected: { email: 'marco@example.com' },
+            invalidValue: '[]',
+            name: 'message sender',
+            schema: appwrite.decodedSchemas.messageSender,
+            value: '{"email":"marco@example.com"}',
+        },
+        {
+            expected: [],
+            invalidValue: '{}',
+            name: 'thread participants',
+            schema: appwrite.decodedSchemas.threadParticipants,
+            value: '[]',
+        },
+    ];
+    for (const testCase of jsonTextTestCases) {
+        it(`decodes ${testCase.name} JSON text`, () => {
+            const result = v.safeParse(testCase.schema, testCase.value);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.output).toEqual(testCase.expected);
+            }
+            expect(v.safeParse(testCase.schema, testCase.invalidValue).success).toBe(false);
+            expect(v.safeParse(testCase.schema, '{').success).toBe(false);
+        });
+    }
+});

package/dist/appwrite/index.d.ts

@@ -0,0 +1,2 @@
+export { type AppwriteRow, type AppwriteRowTable, appwrite } from './appwrite';
+//# sourceMappingURL=index.d.ts.map

package/dist/appwrite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/appwrite/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/appwrite/index.js

@@ -0,0 +1 @@
+export { appwrite } from './appwrite';

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { type AppwriteRow, type AppwriteRowTable, appwrite } from './appwrite';
 export { marcoConstants } from './constants';
 export { MARCO_ENV, MarcoEnvironment, marcoPublicConfig } from './marcoPublicConfig';
 export { type Account, type AccountAlias, type AccountId, type AccountLabel, type AliasId, type AttachmentId, type Contact, type ContactId, type Draft, type DraftAttachment, type DraftBody, type DraftId, type LabelId, type MessageId, marcoSchemas, type PushNotificationTokenId, type RecipientId, type Thread, type ThreadId, type ThreadMessage, type ThreadMessageAttachment, type ThreadMessageRecipient, type User, type UserId, type UserPushNotificationToken, type UserView, type ViewId, } from './schemas';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,YAAY,EACZ,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,IAAI,EACT,KAAK,MAAM,EACX,KAAK,yBAAyB,EAC9B,KAAK,QAAQ,EACb,KAAK,MAAM,GACZ,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,YAAY,EACZ,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,IAAI,EACT,KAAK,MAAM,EACX,KAAK,yBAAyB,EAC9B,KAAK,QAAQ,EACb,KAAK,MAAM,GACZ,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -1,3 +1,4 @@
+export { appwrite } from './appwrite';
 export { marcoConstants } from './constants';
 export { MARCO_ENV, marcoPublicConfig } from './marcoPublicConfig';
 export { marcoSchemas, } from './schemas';

package/dist/schemas/index.d.ts

@@ -586,36 +586,36 @@ export declare const marcoSchemas: {
                         readonly to: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>, undefined>;
                     }, "content">;
                     readonly '~standard': import("valibot").StandardProps<{
+                        subject: string | null;
                         bcc: string[];
                         cc: string[];
                         to: string[];
-                        subject: string | null;
                     }, {
+                        subject: string | null;
                         bcc: string[];
                         cc: string[];
                         to: string[];
-                        subject: string | null;
                     }>;
                     readonly '~run': (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+                        subject: string | null;
                         bcc: string[];
                         cc: string[];
                         to: string[];
-                        subject: string | null;
-                    }, import("valibot").ObjectIssue | import("valibot").StringIssue | import("valibot").ArrayIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").NonOptionalIssue | import("valibot").RfcEmailIssue<string>>;
+                    }, import("valibot").StringIssue | import("valibot").ArrayIssue | import("valibot").ObjectIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").NonOptionalIssue | import("valibot").RfcEmailIssue<string>>;
                     readonly '~types'?: {
                         readonly input: {
+                            subject: string | null;
                             bcc: string[];
                             cc: string[];
                             to: string[];
-                            subject: string | null;
                         };
                         readonly output: {
+                            subject: string | null;
                             bcc: string[];
                             cc: string[];
                             to: string[];
-                            subject: string | null;
                         };
-                        readonly issue: import("valibot").ObjectIssue | import("valibot").StringIssue | import("valibot").ArrayIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").NonOptionalIssue | import("valibot").RfcEmailIssue<string>;
+                        readonly issue: import("valibot").StringIssue | import("valibot").ArrayIssue | import("valibot").ObjectIssue | import("valibot").NonEmptyIssue<string> | import("valibot").MaxLengthIssue<string, number> | import("valibot").NonOptionalIssue | import("valibot").RfcEmailIssue<string>;
                     } | undefined;
                 };
                 readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "DraftId">]>, undefined>;

package/dist/schemas/mutators/mutatorSchemas.d.ts

@@ -161,36 +161,36 @@ export declare const mutatorSchemas: {
                     readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>, undefined>;
                 }, "content">;
                 readonly '~standard': v.StandardProps<{
+                    subject: string | null;
                     bcc: string[];
                     cc: string[];
                     to: string[];
-                    subject: string | null;
                 }, {
+                    subject: string | null;
                     bcc: string[];
                     cc: string[];
                     to: string[];
-                    subject: string | null;
                 }>;
                 readonly '~run': (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                    subject: string | null;
                     bcc: string[];
                     cc: string[];
                     to: string[];
-                    subject: string | null;
-                }, v.ObjectIssue | v.StringIssue | v.ArrayIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string>>;
+                }, v.StringIssue | v.ArrayIssue | v.ObjectIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string>>;
                 readonly '~types'?: {
                     readonly input: {
+                        subject: string | null;
                         bcc: string[];
                         cc: string[];
                         to: string[];
-                        subject: string | null;
                     };
                     readonly output: {
+                        subject: string | null;
                         bcc: string[];
                         cc: string[];
                         to: string[];
-                        subject: string | null;
                     };
-                    readonly issue: v.ObjectIssue | v.StringIssue | v.ArrayIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string>;
+                    readonly issue: v.StringIssue | v.ArrayIssue | v.ObjectIssue | v.NonEmptyIssue<string> | v.MaxLengthIssue<string, number> | v.NonOptionalIssue | v.RfcEmailIssue<string>;
                 } | undefined;
             };
             readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;