@marcoappio/marco-config 4.0.19 → 4.0.21

package/dist/appwrite/queryContracts/queryContracts.js

@@ -0,0 +1,299 @@
+import { appwriteTables } from '../../appwrite/tableContract/index.js';
+export const appwriteQueryIndexRequirementNames = [
+    'accountsByProfileAssignmentKey',
+    'accountsByProfileAssignmentKeyAndState',
+    'accountsByState',
+    'accountsByStateAndPollShardAssignmentId',
+    'accountsByPollShardAssignmentId',
+    'aliasesByAccountAssignmentKey',
+    'aliasesByAccountAssignmentKeyAndProviderId',
+    'labelsByAccountAssignmentKeyAndPath',
+    'labelsByAccountAssignmentKeyAndSpecialUse',
+    'labelsByAccountAssignmentKeyAndProviderId',
+    'contactsByProfileAssignmentKey',
+    'contactsByProfileAssignmentKeyAndLastContactedAt',
+    'contactsByProfileAssignmentKeyAndNormalisedAddress',
+    'contactsBySearchText',
+    'draftsByAccountAssignmentKeyAndStatus',
+    'draftsByAccountAssignmentKey',
+    'draftsByScheduledAt',
+    'threadsByAccountAssignmentKeyAndLatestMessageAt',
+    'threadsByAccountAssignmentKeyAndSeenAndLatestMessageAt',
+    'threadsByAccountAssignmentKeyAndFlaggedAndLatestMessageAt',
+    'threadsByAccountAssignmentKeyAndSnoozedUntilAndLatestMessageAt',
+    'threadsBySnoozedUntil',
+    'threadsByAccountAssignmentKeyAndArchivedAndLatestMessageAt',
+    'threadsByAccountAssignmentKeyAndSpamAndLatestMessageAt',
+    'threadsByAccountAssignmentKeyAndTrashedAndLatestMessageAt',
+    'threadsBySearchText',
+    'threadLabelsByThreadAssignmentKeyAndLabelAssignmentKey',
+    'threadLabelsByLabelAssignmentKeyAndLatestMessageAt',
+    'threadAliasesByThreadAssignmentKeyAndAliasAssignmentKey',
+    'threadAliasesByAliasAssignmentKeyAndLatestMessageAt',
+    'messagesByThreadAssignmentKeyAndSentAt',
+    'messagesByAccountAssignmentKeyAndProviderId',
+    'messagesByAccountAssignmentKeyAndRfcMessageId',
+    'messageLocationsByAccountAssignmentKeyAndLabelAssignmentKeyAndUidValidityAndUid',
+    'messageLocationsByAccountAssignmentKeyAndThreadAssignmentKey',
+    'messageLocationsByThreadAssignmentKeyAndLabelAssignmentKeyAndMessageAt',
+    'mailboxSyncCandidatesByAccountLaneGenerationPriorityReceivedLabelUidUidValidity',
+    'mailboxSyncCandidatesByLane',
+    'mailboxSyncLanesByAccountIdAndLane',
+    'mailboxSyncLanesByLaneAndState',
+    'mailboxSyncStatesByStateAndNextPollAt',
+    'commandsByUserIdAndSubmittedAt',
+    'commandsByUserId',
+    'commandsByAccountIdAndState',
+    'commandsByStateAndSubmittedAt',
+    'jobsByStateAndNextRunAt',
+    'jobsByStateAndLeaseExpiresAt',
+    'jobsByUserIdAndStateAndLeaseExpiresAt',
+    'jobsByStateAndLeaseExpiresAtAndLeaseIdAndAttempts',
+    'jobsByCommandId',
+    'jobsByDedupeKey',
+    'jobsByUserId',
+    'pollShardsByStateAndNextStartAt',
+    'pollShardsByLeaseExpiresAt',
+    'pushNotificationTokensByUserId',
+    'pushNotificationTokensByToken',
+];
+export const appwriteQueryIndexRequirements = {
+    accountsByPollShardAssignmentId: { attributes: ['pollShardAssignmentId'], kind: 'filter', tableKey: 'accounts' },
+    accountsByProfileAssignmentKey: { attributes: ['profileAssignmentKey'], kind: 'filter', tableKey: 'accounts' },
+    accountsByProfileAssignmentKeyAndState: { attributes: ['profileAssignmentKey', 'state'], kind: 'filter', tableKey: 'accounts' },
+    accountsByState: { attributes: ['state'], kind: 'filter', tableKey: 'accounts' },
+    accountsByStateAndPollShardAssignmentId: { attributes: ['state', 'pollShardAssignmentId'], kind: 'filter', tableKey: 'accounts' },
+    aliasesByAccountAssignmentKey: { attributes: ['accountAssignmentKey'], kind: 'filter', tableKey: 'aliases' },
+    aliasesByAccountAssignmentKeyAndProviderId: { attributes: ['accountAssignmentKey', 'providerId'], kind: 'filter', tableKey: 'aliases' },
+    commandsByAccountIdAndState: { attributes: ['accountId', 'state'], kind: 'filter', tableKey: 'commands' },
+    commandsByStateAndSubmittedAt: { attributes: ['state', 'submittedAt'], kind: 'filter', tableKey: 'commands' },
+    commandsByUserId: { attributes: ['userId'], kind: 'filter', tableKey: 'commands' },
+    commandsByUserIdAndSubmittedAt: { attributes: ['userId', 'submittedAt'], kind: 'filter', tableKey: 'commands' },
+    contactsByProfileAssignmentKey: { attributes: ['profileAssignmentKey'], kind: 'filter', tableKey: 'contacts' },
+    contactsByProfileAssignmentKeyAndLastContactedAt: { attributes: ['profileAssignmentKey', 'lastContactedAt'], kind: 'filter', tableKey: 'contacts' },
+    contactsByProfileAssignmentKeyAndNormalisedAddress: { attributes: ['profileAssignmentKey', 'normalisedAddress'], kind: 'filter', tableKey: 'contacts' },
+    contactsBySearchText: { attributes: ['searchText'], kind: 'fulltext', tableKey: 'contacts' },
+    draftsByAccountAssignmentKey: { attributes: ['accountAssignmentKey'], kind: 'filter', tableKey: 'drafts' },
+    draftsByAccountAssignmentKeyAndStatus: { attributes: ['accountAssignmentKey', 'status'], kind: 'filter', tableKey: 'drafts' },
+    draftsByScheduledAt: { attributes: ['scheduledAt'], kind: 'filter', tableKey: 'drafts' },
+    jobsByCommandId: { attributes: ['commandId'], kind: 'filter', tableKey: 'jobs' },
+    jobsByDedupeKey: { attributes: ['dedupeKey'], kind: 'filter', tableKey: 'jobs' },
+    jobsByStateAndLeaseExpiresAt: { attributes: ['state', 'leaseExpiresAt'], kind: 'filter', tableKey: 'jobs' },
+    jobsByStateAndLeaseExpiresAtAndLeaseIdAndAttempts: { attributes: ['state', 'leaseExpiresAt', 'leaseId', 'attempts'], kind: 'filter', tableKey: 'jobs' },
+    jobsByStateAndNextRunAt: { attributes: ['state', 'nextRunAt'], kind: 'filter', tableKey: 'jobs' },
+    jobsByUserId: { attributes: ['userId'], kind: 'filter', tableKey: 'jobs' },
+    jobsByUserIdAndStateAndLeaseExpiresAt: { attributes: ['userId', 'state', 'leaseExpiresAt'], kind: 'filter', tableKey: 'jobs' },
+    labelsByAccountAssignmentKeyAndPath: { attributes: ['accountAssignmentKey', 'path'], kind: 'filter', tableKey: 'labels' },
+    labelsByAccountAssignmentKeyAndProviderId: { attributes: ['accountAssignmentKey', 'providerId'], kind: 'filter', tableKey: 'labels' },
+    labelsByAccountAssignmentKeyAndSpecialUse: { attributes: ['accountAssignmentKey', 'specialUse'], kind: 'filter', tableKey: 'labels' },
+    mailboxSyncCandidatesByAccountLaneGenerationPriorityReceivedLabelUidUidValidity: {
+        attributes: ['accountId', 'lane', 'generation', 'mailboxPriority', 'receivedAt', 'labelId', 'uid', 'uidValidity'],
+        kind: 'filter',
+        tableKey: 'mailboxSyncCandidates',
+    },
+    mailboxSyncCandidatesByLane: { attributes: ['lane'], kind: 'filter', tableKey: 'mailboxSyncCandidates' },
+    mailboxSyncLanesByAccountIdAndLane: { attributes: ['accountId', 'lane'], kind: 'filter', tableKey: 'mailboxSyncLanes' },
+    mailboxSyncLanesByLaneAndState: { attributes: ['lane', 'state'], kind: 'filter', tableKey: 'mailboxSyncLanes' },
+    mailboxSyncStatesByStateAndNextPollAt: { attributes: ['state', 'nextPollAt'], kind: 'filter', tableKey: 'mailboxSyncStates' },
+    messageLocationsByAccountAssignmentKeyAndLabelAssignmentKeyAndUidValidityAndUid: {
+        attributes: ['accountAssignmentKey', 'labelAssignmentKey', 'uidValidity', 'uid'],
+        kind: 'filter',
+        tableKey: 'messageLocations',
+    },
+    messageLocationsByAccountAssignmentKeyAndThreadAssignmentKey: { attributes: ['accountAssignmentKey', 'threadAssignmentKey'], kind: 'filter', tableKey: 'messageLocations' },
+    messageLocationsByThreadAssignmentKeyAndLabelAssignmentKeyAndMessageAt: {
+        attributes: ['threadAssignmentKey', 'labelAssignmentKey', 'messageAt'],
+        kind: 'filter',
+        tableKey: 'messageLocations',
+    },
+    messagesByAccountAssignmentKeyAndProviderId: { attributes: ['accountAssignmentKey', 'providerId'], kind: 'filter', tableKey: 'messages' },
+    messagesByAccountAssignmentKeyAndRfcMessageId: { attributes: ['accountAssignmentKey', 'rfcMessageId'], kind: 'filter', tableKey: 'messages' },
+    messagesByThreadAssignmentKeyAndSentAt: { attributes: ['threadAssignmentKey', 'sentAt'], kind: 'filter', tableKey: 'messages' },
+    pollShardsByLeaseExpiresAt: { attributes: ['leaseExpiresAt'], kind: 'filter', tableKey: 'pollShards' },
+    pollShardsByStateAndNextStartAt: { attributes: ['state', 'nextStartAt'], kind: 'filter', tableKey: 'pollShards' },
+    pushNotificationTokensByToken: { attributes: ['token'], kind: 'filter', tableKey: 'pushNotificationTokens' },
+    pushNotificationTokensByUserId: { attributes: ['userId'], kind: 'filter', tableKey: 'pushNotificationTokens' },
+    threadAliasesByAliasAssignmentKeyAndLatestMessageAt: { attributes: ['aliasAssignmentKey', 'latestMessageAt'], kind: 'filter', tableKey: 'threadAliases' },
+    threadAliasesByThreadAssignmentKeyAndAliasAssignmentKey: { attributes: ['threadAssignmentKey', 'aliasAssignmentKey'], kind: 'filter', tableKey: 'threadAliases' },
+    threadLabelsByLabelAssignmentKeyAndLatestMessageAt: { attributes: ['labelAssignmentKey', 'latestMessageAt'], kind: 'filter', tableKey: 'threadLabels' },
+    threadLabelsByThreadAssignmentKeyAndLabelAssignmentKey: { attributes: ['threadAssignmentKey', 'labelAssignmentKey'], kind: 'filter', tableKey: 'threadLabels' },
+    threadsByAccountAssignmentKeyAndArchivedAndLatestMessageAt: { attributes: ['accountAssignmentKey', 'archived', 'latestMessageAt'], kind: 'filter', tableKey: 'threads' },
+    threadsByAccountAssignmentKeyAndFlaggedAndLatestMessageAt: { attributes: ['accountAssignmentKey', 'flagged', 'latestMessageAt'], kind: 'filter', tableKey: 'threads' },
+    threadsByAccountAssignmentKeyAndLatestMessageAt: { attributes: ['accountAssignmentKey', 'latestMessageAt'], kind: 'filter', tableKey: 'threads' },
+    threadsByAccountAssignmentKeyAndSeenAndLatestMessageAt: { attributes: ['accountAssignmentKey', 'seen', 'latestMessageAt'], kind: 'filter', tableKey: 'threads' },
+    threadsByAccountAssignmentKeyAndSnoozedUntilAndLatestMessageAt: { attributes: ['accountAssignmentKey', 'snoozedUntil', 'latestMessageAt'], kind: 'filter', tableKey: 'threads' },
+    threadsByAccountAssignmentKeyAndSpamAndLatestMessageAt: { attributes: ['accountAssignmentKey', 'spam', 'latestMessageAt'], kind: 'filter', tableKey: 'threads' },
+    threadsByAccountAssignmentKeyAndTrashedAndLatestMessageAt: { attributes: ['accountAssignmentKey', 'trashed', 'latestMessageAt'], kind: 'filter', tableKey: 'threads' },
+    threadsBySearchText: { attributes: ['searchText'], kind: 'fulltext', tableKey: 'threads' },
+    threadsBySnoozedUntil: { attributes: ['snoozedUntil'], kind: 'filter', tableKey: 'threads' },
+};
+const appwriteQueryConsumers = ['BACKEND', 'FRONTEND'];
+export const appwriteQueryContractNames = [
+    'accounts',
+    'aliases',
+    'labels',
+    'contacts',
+    'drafts',
+    'threads',
+    'threadLabels',
+    'threadAliases',
+    'messages',
+    'messageLocations',
+    'mailboxSyncCandidates',
+    'mailboxSyncLanes',
+    'mailboxSyncStates',
+    'commands',
+    'jobs',
+    'pollShards',
+    'pushNotificationTokens',
+];
+const appwriteQueryContractInputs = {
+    accounts: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: [
+            'accountsByProfileAssignmentKey',
+            'accountsByProfileAssignmentKeyAndState',
+            'accountsByState',
+            'accountsByStateAndPollShardAssignmentId',
+            'accountsByPollShardAssignmentId',
+        ],
+        tableKey: 'accounts',
+    },
+    aliases: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: ['aliasesByAccountAssignmentKey', 'aliasesByAccountAssignmentKeyAndProviderId'],
+        tableKey: 'aliases',
+    },
+    commands: {
+        consumers: ['BACKEND'],
+        requirements: ['commandsByUserIdAndSubmittedAt', 'commandsByUserId', 'commandsByAccountIdAndState', 'commandsByStateAndSubmittedAt'],
+        tableKey: 'commands',
+    },
+    contacts: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: [
+            'contactsByProfileAssignmentKey',
+            'contactsByProfileAssignmentKeyAndLastContactedAt',
+            'contactsByProfileAssignmentKeyAndNormalisedAddress',
+            'contactsBySearchText',
+        ],
+        tableKey: 'contacts',
+    },
+    drafts: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: ['draftsByAccountAssignmentKeyAndStatus', 'draftsByAccountAssignmentKey', 'draftsByScheduledAt'],
+        tableKey: 'drafts',
+    },
+    jobs: {
+        consumers: ['BACKEND'],
+        requirements: [
+            'jobsByStateAndNextRunAt',
+            'jobsByStateAndLeaseExpiresAt',
+            'jobsByUserIdAndStateAndLeaseExpiresAt',
+            'jobsByStateAndLeaseExpiresAtAndLeaseIdAndAttempts',
+            'jobsByCommandId',
+            'jobsByDedupeKey',
+            'jobsByUserId',
+        ],
+        tableKey: 'jobs',
+    },
+    labels: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: ['labelsByAccountAssignmentKeyAndPath', 'labelsByAccountAssignmentKeyAndSpecialUse', 'labelsByAccountAssignmentKeyAndProviderId'],
+        tableKey: 'labels',
+    },
+    mailboxSyncCandidates: {
+        consumers: ['BACKEND'],
+        requirements: ['mailboxSyncCandidatesByAccountLaneGenerationPriorityReceivedLabelUidUidValidity', 'mailboxSyncCandidatesByLane'],
+        tableKey: 'mailboxSyncCandidates',
+    },
+    mailboxSyncLanes: {
+        consumers: ['BACKEND'],
+        requirements: ['mailboxSyncLanesByAccountIdAndLane', 'mailboxSyncLanesByLaneAndState'],
+        tableKey: 'mailboxSyncLanes',
+    },
+    mailboxSyncStates: {
+        consumers: ['BACKEND'],
+        requirements: ['mailboxSyncStatesByStateAndNextPollAt'],
+        tableKey: 'mailboxSyncStates',
+    },
+    messageLocations: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: [
+            'messageLocationsByAccountAssignmentKeyAndLabelAssignmentKeyAndUidValidityAndUid',
+            'messageLocationsByAccountAssignmentKeyAndThreadAssignmentKey',
+            'messageLocationsByThreadAssignmentKeyAndLabelAssignmentKeyAndMessageAt',
+        ],
+        tableKey: 'messageLocations',
+    },
+    messages: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: ['messagesByThreadAssignmentKeyAndSentAt', 'messagesByAccountAssignmentKeyAndProviderId', 'messagesByAccountAssignmentKeyAndRfcMessageId'],
+        tableKey: 'messages',
+    },
+    pollShards: {
+        consumers: ['BACKEND'],
+        requirements: ['pollShardsByStateAndNextStartAt', 'pollShardsByLeaseExpiresAt'],
+        tableKey: 'pollShards',
+    },
+    pushNotificationTokens: {
+        consumers: ['BACKEND'],
+        requirements: ['pushNotificationTokensByUserId', 'pushNotificationTokensByToken'],
+        tableKey: 'pushNotificationTokens',
+    },
+    threadAliases: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: ['threadAliasesByThreadAssignmentKeyAndAliasAssignmentKey', 'threadAliasesByAliasAssignmentKeyAndLatestMessageAt'],
+        tableKey: 'threadAliases',
+    },
+    threadLabels: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: ['threadLabelsByThreadAssignmentKeyAndLabelAssignmentKey', 'threadLabelsByLabelAssignmentKeyAndLatestMessageAt'],
+        tableKey: 'threadLabels',
+    },
+    threads: {
+        consumers: ['BACKEND', 'FRONTEND'],
+        requirements: [
+            'threadsByAccountAssignmentKeyAndLatestMessageAt',
+            'threadsByAccountAssignmentKeyAndSeenAndLatestMessageAt',
+            'threadsByAccountAssignmentKeyAndFlaggedAndLatestMessageAt',
+            'threadsByAccountAssignmentKeyAndSnoozedUntilAndLatestMessageAt',
+            'threadsBySnoozedUntil',
+            'threadsByAccountAssignmentKeyAndArchivedAndLatestMessageAt',
+            'threadsByAccountAssignmentKeyAndSpamAndLatestMessageAt',
+            'threadsByAccountAssignmentKeyAndTrashedAndLatestMessageAt',
+            'threadsBySearchText',
+        ],
+        tableKey: 'threads',
+    },
+};
+export const appwriteQueryContracts = appwriteQueryContractInputs;
+const appwriteQueryConsumerSet = new Set(appwriteQueryConsumers);
+const isAppwriteQueryConsumer = (value) => appwriteQueryConsumerSet.has(value);
+export const validateAppwriteQueryContracts = () => {
+    const physicalRequirements = new Set();
+    for (const name of appwriteQueryIndexRequirementNames) {
+        const requirement = appwriteQueryIndexRequirements[name];
+        const physicalKey = JSON.stringify([requirement.tableKey, requirement.kind, requirement.attributes]);
+        const table = appwriteTables[requirement.tableKey];
+        const matchingIndex = table.indexes.some(index => {
+            const indexTypeMatches = requirement.kind === 'fulltext' ? index.type === 'fulltext' : index.type !== 'fulltext';
+            // Appwrite permits a query to use the left prefix of a composite index
+            const attributesMatch = index.attributes.length >= requirement.attributes.length && requirement.attributes.every((attribute, indexPosition) => index.attributes[indexPosition] === attribute);
+            return indexTypeMatches && attributesMatch;
+        });
+        if (physicalRequirements.has(physicalKey) || !matchingIndex) {
+            throw new Error(`Invalid Appwrite query index requirement: ${name}`);
+        }
+        physicalRequirements.add(physicalKey);
+    }
+    for (const name of appwriteQueryContractNames) {
+        const contract = appwriteQueryContracts[name];
+        const consumersAreValid = contract.consumers.length > 0 && contract.consumers.every(isAppwriteQueryConsumer);
+        const requirementsAreValid = contract.requirements.length > 0 && contract.requirements.every(requirementName => appwriteQueryIndexRequirements[requirementName].tableKey === contract.tableKey);
+        if (!(consumersAreValid && requirementsAreValid)) {
+            throw new Error(`Invalid Appwrite query contract: ${name}`);
+        }
+    }
+};
+validateAppwriteQueryContracts();

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

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

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

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

package/dist/appwrite/queryContracts/queryContracts.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'bun:test';
+import { appwriteQueryContracts, appwriteQueryIndexRequirements, appwriteQueryIndexRequirementNames, appwriteQueryContractNames, validateAppwriteQueryContracts, } from './queryContracts.js';
+describe('Appwrite query contracts', () => {
+    it('publishes unique physical requirements', () => {
+        const physicalRequirements = appwriteQueryIndexRequirementNames.map(name => {
+            const requirement = appwriteQueryIndexRequirements[name];
+            return JSON.stringify([requirement.tableKey, requirement.kind, requirement.attributes]);
+        });
+        expect(new Set(physicalRequirements).size).toBe(physicalRequirements.length);
+    });
+    it('references only same-table requirements and valid consumers', () => {
+        expect(() => validateAppwriteQueryContracts()).not.toThrow();
+        for (const name of appwriteQueryContractNames) {
+            const contract = appwriteQueryContracts[name];
+            expect(contract.consumers.length).toBeGreaterThan(0);
+            for (const requirementName of contract.requirements) {
+                expect(appwriteQueryIndexRequirements[requirementName].tableKey).toBe(contract.tableKey);
+            }
+        }
+    });
+    it('contains the physical index tuples currently required by Appwrite provisioning', () => {
+        expect(Object.keys(appwriteQueryIndexRequirements)).toHaveLength(appwriteQueryIndexRequirementNames.length);
+        expect(appwriteQueryIndexRequirements.jobsByStateAndNextRunAt).toEqual({
+            attributes: ['state', 'nextRunAt'],
+            kind: 'filter',
+            tableKey: 'jobs',
+        });
+        expect(appwriteQueryIndexRequirements.threadsByAccountAssignmentKeyAndSeenAndLatestMessageAt).toEqual({
+            attributes: ['accountAssignmentKey', 'seen', 'latestMessageAt'],
+            kind: 'filter',
+            tableKey: 'threads',
+        });
+        expect(appwriteQueryIndexRequirements.contactsBySearchText).toEqual({
+            attributes: ['searchText'],
+            kind: 'fulltext',
+            tableKey: 'contacts',
+        });
+    });
+});

package/dist/appwrite/tableContract/identity.d.ts

@@ -1,40 +1,40 @@
-import * as v from 'valibot';
+import { v } from '../../utils/valibot/index.js';
 export declare const identityTableInputs: {
     readonly accounts: {
         readonly fields: {
-            readonly profileAssignmentKey: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
-            readonly provider: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["GMAIL", "OUTLOOK", "IMAP"], undefined>>;
-            readonly state: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "ERROR", "DISCONNECTED"], undefined>>;
-            readonly primaryEmail: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>>;
-            readonly displayName: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
             readonly colour: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 64, undefined>]>>;
-            readonly pollShardAssignmentId: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
-            readonly pollShardId: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
-            readonly lastSuccessfulSyncAt: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>>;
-            readonly lastErrorCode: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
-            readonly mailProcessedCount: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>>;
-            readonly mailTotalCount: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>>;
-            readonly initialSyncCompletedAt: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>>;
             readonly credential: import("./shared.js").AppwriteRelationshipSchema<v.NullableSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
             }, undefined>, v.TransformAction<{
                 $id: string;
             }, string>]>], undefined>, undefined>>;
+            readonly displayName: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
+            readonly initialSyncCompletedAt: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>>;
+            readonly lastErrorCode: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
+            readonly lastSuccessfulSyncAt: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>>;
             readonly mailboxSyncState: import("./shared.js").AppwriteRelationshipSchema<v.NullableSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
             }, undefined>, v.TransformAction<{
                 $id: string;
             }, string>]>], undefined>, undefined>>;
+            readonly mailProcessedCount: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>>;
+            readonly mailTotalCount: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>>;
+            readonly pollShardAssignmentId: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
+            readonly pollShardId: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
             readonly primaryAlias: import("./shared.js").AppwriteRelationshipSchema<v.NullableSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
             }, undefined>, v.TransformAction<{
                 $id: string;
             }, string>]>], undefined>, undefined>>;
+            readonly primaryEmail: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>>;
             readonly profile: import("./shared.js").AppwriteRelationshipSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
             }, undefined>, v.TransformAction<{
                 $id: string;
             }, string>]>], undefined>>;
+            readonly profileAssignmentKey: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
+            readonly provider: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["GMAIL", "OUTLOOK", "IMAP"], undefined>>;
+            readonly state: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "ERROR", "DISCONNECTED"], undefined>>;
         };
         readonly indexes: readonly [{
             readonly attributes: readonly ["profileAssignmentKey"];
@@ -65,17 +65,17 @@ export declare const identityTableInputs: {
     };
     readonly aliases: {
         readonly fields: {
-            readonly accountAssignmentKey: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
-            readonly providerId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
-            readonly email: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>>;
-            readonly name: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
-            readonly signature: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>>;
-            readonly isPrimary: import("./shared.js").AppwriteColumnSchema<v.BooleanSchema<undefined>>;
             readonly account: import("./shared.js").AppwriteRelationshipSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
             }, undefined>, v.TransformAction<{
                 $id: string;
             }, string>]>], undefined>>;
+            readonly accountAssignmentKey: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
+            readonly email: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>>;
+            readonly isPrimary: import("./shared.js").AppwriteColumnSchema<v.BooleanSchema<undefined>>;
+            readonly name: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
+            readonly providerId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
+            readonly signature: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>>;
         };
         readonly indexes: readonly [{
             readonly attributes: readonly ["accountAssignmentKey"];
@@ -90,13 +90,13 @@ export declare const identityTableInputs: {
     };
     readonly credentials: {
         readonly fields: {
-            readonly userId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
             readonly accountId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
-            readonly provider: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["GMAIL", "OUTLOOK", "IMAP"], undefined>>;
             readonly encryptedPayload: import("./shared.js").AppwriteColumnSchema<v.StringSchema<undefined>>;
             readonly expiresAt: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>>;
+            readonly provider: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["GMAIL", "OUTLOOK", "IMAP"], undefined>>;
             readonly refreshLeaseExpiresAt: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, v.CheckAction<string, undefined>]>, undefined>>;
             readonly refreshLeaseId: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
+            readonly userId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
         };
         readonly indexes: readonly [{
             readonly attributes: readonly ["userId"];
@@ -111,18 +111,18 @@ export declare const identityTableInputs: {
     };
     readonly labels: {
         readonly fields: {
+            readonly account: import("./shared.js").AppwriteRelationshipSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
+            }, undefined>, v.TransformAction<{
+                $id: string;
+            }, string>]>], undefined>>;
             readonly accountAssignmentKey: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
-            readonly providerId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
             readonly name: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
             readonly path: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
+            readonly providerId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
             readonly specialUse: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.PicklistSchema<readonly ["ALL", "ARCHIVE", "DRAFTS", "INBOX", "JUNK", "SENT", "STARRED", "TRASH"], undefined>, undefined>>;
             readonly totalCount: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>>;
             readonly unreadCount: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>>;
-            readonly account: import("./shared.js").AppwriteRelationshipSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
-            }, undefined>, v.TransformAction<{
-                $id: string;
-            }, string>]>], undefined>>;
         };
         readonly indexes: readonly [{
             readonly attributes: readonly ["accountAssignmentKey", "specialUse"];
@@ -141,28 +141,28 @@ export declare const identityTableInputs: {
     };
     readonly oauthStates: {
         readonly fields: {
-            readonly userId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
             readonly accountId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
             readonly email: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>>;
             readonly expiresAt: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>>;
             readonly nonceHash: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
             readonly operation: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["CONNECT", "REPLACE"], undefined>>;
-            readonly provider: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["GMAIL", "OUTLOOK"], undefined>>;
-            readonly returnUri: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["https://app.marcoapp.io/onboarding/loading"], undefined>>;
             readonly profile: import("./shared.js").AppwriteRelationshipSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
             }, undefined>, v.TransformAction<{
                 $id: string;
             }, string>]>], undefined>>;
+            readonly provider: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["GMAIL", "OUTLOOK"], undefined>>;
+            readonly returnUri: import("./shared.js").AppwriteColumnSchema<v.PicklistSchema<readonly ["https://app.marcoapp.io/onboarding/loading"], undefined>>;
+            readonly userId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
         };
         readonly indexes: readonly [];
         readonly name: "OAuth states";
     };
     readonly profileAvatarCleanups: {
         readonly fields: {
-            readonly fileId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
-            readonly claimId: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
             readonly claimedAt: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>>;
+            readonly claimId: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
+            readonly fileId: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
             readonly profile: import("./shared.js").AppwriteRelationshipSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
             }, undefined>, v.TransformAction<{
@@ -175,9 +175,9 @@ export declare const identityTableInputs: {
     };
     readonly profiles: {
         readonly fields: {
-            readonly email: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>>;
             readonly avatarFileId: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 36, undefined>, v.RegexAction<string, undefined>]>, undefined>>;
             readonly deletionRequestedAt: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>>;
+            readonly email: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>>;
             readonly name: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
             readonly onboardingState: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
             readonly timezone: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
@@ -191,9 +191,9 @@ export declare const identityTableInputs: {
     };
     readonly savedViews: {
         readonly fields: {
-            readonly name: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
-            readonly icon: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
             readonly aliasIds: import("./shared.js").AppwriteColumnSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
+            readonly icon: import("./shared.js").AppwriteColumnSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>>;
+            readonly name: import("./shared.js").AppwriteColumnSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>>;
             readonly profile: import("./shared.js").AppwriteRelationshipSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly $id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 255, undefined>]>;
             }, undefined>, v.TransformAction<{

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

@@ -1 +1 @@
-{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../../src/appwrite/tableContract/identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AA0B5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiI9B,CAAA"}
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../../src/appwrite/tableContract/identity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,6BAA6B,CAAA;AAwB/C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqK9B,CAAA"}