@marcoappio/marco-config 2.0.407 → 2.0.409

package/dist/sdk/endpoints/private/sync/push/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmC,CAAA"}

package/dist/sdk/endpoints/private/sync/push/index.js

@@ -1,5 +0,0 @@
-import { syncPushAccount as account } from './account';
-import { syncPushDraft as draft } from './draft';
-import { syncPushThread as thread } from './thread';
-import { syncPushUser as user } from './user';
-export const push = { account, draft, thread, user };

package/dist/sdk/endpoints/private/sync/push/thread.d.ts

@@ -1,133 +0,0 @@
-import * as v from 'valibot';
-export declare const syncPushThread: import("../../../../..").EndpointConfig<"/v1/pv/sync/push/thread", v.ObjectSchema<{
-    readonly clientGroupID: v.StringSchema<undefined>;
-    readonly mutations: v.ArraySchema<v.UnionSchema<(v.ObjectSchema<{
-        readonly args: v.ObjectSchema<{
-            readonly labelPath: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"addLabel", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.UnionSchema<[v.ObjectSchema<{
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"delete", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.ObjectSchema<{
-            readonly labelPath: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"removeLabel", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.UnionSchema<readonly [v.ObjectSchema<{
-            readonly attachmentId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly attachmentIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"requestAttachmentDownload", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.UnionSchema<[v.ObjectSchema<{
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setArchive", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.UnionSchema<readonly [v.ObjectSchema<{
-            readonly flagged: v.NonOptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly flagged: v.NonOptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setFlagged", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.UnionSchema<[v.ObjectSchema<{
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setInbox", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.UnionSchema<readonly [v.ObjectSchema<{
-            readonly labelIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly labelIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setLabels", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.UnionSchema<readonly [v.ObjectSchema<{
-            readonly seen: v.BooleanSchema<undefined>;
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly seen: v.BooleanSchema<undefined>;
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setSeen", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.UnionSchema<[v.ObjectSchema<{
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setSpam", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.UnionSchema<[v.ObjectSchema<{
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        }, undefined>], undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setTrash", undefined>;
-    }, undefined>)[], undefined>, undefined>;
-}, undefined>, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
-        readonly issues: v.ObjectSchema<{
-            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<400, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"MUTATION_REJECTED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<409, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=thread.d.ts.map

package/dist/sdk/endpoints/private/sync/push/thread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/thread.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoFzB,CAAA"}

package/dist/sdk/endpoints/private/sync/push/thread.js

@@ -1,85 +0,0 @@
-import * as v from 'valibot';
-import { thread } from '../../../../../clients/thread';
-import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { errors } from '../../../../../sdk/validation/errors';
-export const syncPushThread = createEndpoint({
-    body: v.object({
-        clientGroupID: v.string(),
-        mutations: v.array(v.union(Object.values({
-            addLabel: v.object({
-                args: thread.mutators.addLabel.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('addLabel'),
-            }),
-            delete: v.object({
-                args: thread.mutators.delete.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('delete'),
-            }),
-            removeLabel: v.object({
-                args: thread.mutators.removeLabel.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('removeLabel'),
-            }),
-            requestAttachmentDownload: v.object({
-                args: thread.mutators.requestAttachmentDownload.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('requestAttachmentDownload'),
-            }),
-            setArchive: v.object({
-                args: thread.mutators.setArchive.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setArchive'),
-            }),
-            setFlagged: v.object({
-                args: thread.mutators.setFlagged.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setFlagged'),
-            }),
-            setInbox: v.object({
-                args: thread.mutators.setInbox.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setInbox'),
-            }),
-            setLabels: v.object({
-                args: thread.mutators.setLabels.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setLabels'),
-            }),
-            setSeen: v.object({
-                args: thread.mutators.setSeen.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setSeen'),
-            }),
-            setSpam: v.object({
-                args: thread.mutators.setSpam.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setSpam'),
-            }),
-            setTrash: v.object({
-                args: thread.mutators.setTrash.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setTrash'),
-            }),
-        }))),
-    }),
-    method: 'POST',
-    path: thread.pushUrl,
-    response: v.union([
-        errors.validationFailedErrorSchema,
-        errors.authFailedErrorSchema,
-        errors.mutationRejectedErrorSchema,
-        v.object({ status: v.literal(200) }),
-    ]),
-});

package/dist/sdk/endpoints/private/sync/push/user.d.ts

@@ -1,64 +0,0 @@
-import * as v from 'valibot';
-export declare const syncPushUser: import("../../../../..").EndpointConfig<"/v1/pv/sync/push/user", v.ObjectSchema<{
-    readonly clientGroupID: v.StringSchema<undefined>;
-    readonly mutations: v.ArraySchema<v.UnionSchema<(v.ObjectSchema<{
-        readonly args: v.ObjectSchema<{
-            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly token: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"deleteSettingsPushNotificationToken", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.ObjectSchema<{
-            readonly deviceId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"deleteSettingsPushNotificationTokenForDevice", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.ObjectSchema<{
-            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setSettingsName", undefined>;
-    }, undefined> | v.ObjectSchema<{
-        readonly args: v.ObjectSchema<{
-            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly pushNotificationToken: v.ObjectSchema<{
-                readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                readonly deviceId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly token: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>;
-        }, undefined>;
-        readonly clientID: v.StringSchema<undefined>;
-        readonly id: v.NumberSchema<undefined>;
-        readonly name: v.LiteralSchema<"setSettingsPushNotificationToken", undefined>;
-    }, undefined>)[], undefined>, undefined>;
-}, undefined>, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
-        readonly issues: v.ObjectSchema<{
-            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<400, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"MUTATION_REJECTED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<409, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=user.d.ts.map

package/dist/sdk/endpoints/private/sync/push/user.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/sync/push/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA0CvB,CAAA"}

package/dist/sdk/endpoints/private/sync/push/user.js

@@ -1,43 +0,0 @@
-import * as v from 'valibot';
-import { user } from '../../../../../clients/user';
-import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { errors } from '../../../../../sdk/validation/errors';
-export const syncPushUser = createEndpoint({
-    body: v.object({
-        clientGroupID: v.string(),
-        mutations: v.array(v.union(Object.values({
-            deleteSettingsPushNotificationToken: v.object({
-                args: user.mutators.deleteSettingsPushNotificationToken.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('deleteSettingsPushNotificationToken'),
-            }),
-            deleteSettingsPushNotificationTokenForDevice: v.object({
-                args: user.mutators.deleteSettingsPushNotificationTokenForDevice.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('deleteSettingsPushNotificationTokenForDevice'),
-            }),
-            setSettingsName: v.object({
-                args: user.mutators.setSettingsName.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setSettingsName'),
-            }),
-            setSettingsPushNotificationToken: v.object({
-                args: user.mutators.setSettingsPushNotificationToken.delta,
-                clientID: v.string(),
-                id: v.number(),
-                name: v.literal('setSettingsPushNotificationToken'),
-            }),
-        }))),
-    }),
-    method: 'POST',
-    path: user.pushUrl,
-    response: v.union([
-        errors.validationFailedErrorSchema,
-        errors.authFailedErrorSchema,
-        errors.mutationRejectedErrorSchema,
-        v.object({ status: v.literal(200) }),
-    ]),
-});

package/dist/sdk/endpoints/private/user/deleteUser.d.ts

@@ -1,10 +0,0 @@
-import * as v from 'valibot';
-export declare const deleteUser: import("../../../..").EndpointConfig<"/v1/pv/user", v.GenericSchema | undefined, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly status: v.LiteralSchema<204, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=deleteUser.d.ts.map

package/dist/sdk/endpoints/private/user/deleteUser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deleteUser.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/user/deleteUser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,UAAU;;;;;;;2BASrB,CAAA"}

package/dist/sdk/endpoints/private/user/deleteUser.js

@@ -1,13 +0,0 @@
-import * as v from 'valibot';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { authFailedErrorSchema } from '../../../../sdk/validation/errors';
-export const deleteUser = createEndpoint({
-    method: 'DELETE',
-    path: '/v1/pv/user',
-    response: v.union([
-        authFailedErrorSchema,
-        v.object({
-            status: v.literal(204),
-        }),
-    ]),
-});

package/dist/sdk/endpoints/private/user/index.d.ts

@@ -1,11 +0,0 @@
-export declare const user: {
-    deleteUser: import("../../../..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly status: import("valibot").LiteralSchema<204, undefined>;
-    }, undefined>], undefined>>;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/endpoints/private/user/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/user/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;CAEhB,CAAA"}

package/dist/sdk/endpoints/private/user/index.js

@@ -1,4 +0,0 @@
-import { deleteUser } from './deleteUser';
-export const user = {
-    deleteUser,
-};

package/dist/sdk/endpoints/public/auth/index.d.ts

@@ -1,137 +0,0 @@
-export declare const auth: {
-    refreshAuth: import("../../../..").EndpointConfig<"/v1/pb/auth/refresh", import("valibot").ObjectSchema<{
-        readonly refreshToken: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
-            readonly issues: import("valibot").ObjectSchema<{
-                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-            }, undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<400, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<502, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly accessToken: import("valibot").StringSchema<undefined>;
-            readonly refreshToken: import("valibot").StringSchema<undefined>;
-            readonly user: import("valibot").ObjectSchema<{
-                readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-                readonly emailVerified: import("valibot").BooleanSchema<undefined>;
-                readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, 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>]>, undefined>;
-                readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<200, undefined>;
-    }, undefined>], undefined>>;
-    sendAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/send-code", import("valibot").ObjectSchema<{
-        readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-    }, undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
-            readonly issues: import("valibot").ObjectSchema<{
-                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-            }, undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<400, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<502, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"INVITE_NOT_FOUND", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<404, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly status: import("valibot").LiteralSchema<200, undefined>;
-    }, undefined>], undefined>>;
-    verifyAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/verify-code", import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly authType: import("valibot").LiteralSchema<"CODE", undefined>;
-        readonly code: import("valibot").StringSchema<undefined>;
-        readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly authType: import("valibot").LiteralSchema<"PASSWORD", undefined>;
-        readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-        readonly password: import("valibot").StringSchema<undefined>;
-    }, undefined>], undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
-            readonly issues: import("valibot").ObjectSchema<{
-                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-            }, undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<400, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_INVALID", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<502, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<404, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<409, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly accessToken: import("valibot").StringSchema<undefined>;
-            readonly refreshToken: import("valibot").StringSchema<undefined>;
-            readonly user: import("valibot").ObjectSchema<{
-                readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
-                readonly emailVerified: import("valibot").BooleanSchema<undefined>;
-                readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, 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>]>, undefined>;
-                readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<200, undefined>;
-    }, undefined>], undefined>>;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/endpoints/public/auth/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIhB,CAAA"}

package/dist/sdk/endpoints/public/auth/index.js

@@ -1,8 +0,0 @@
-import { refreshAuth } from './refreshAuth';
-import { sendAuthCode } from './sendAuthCode';
-import { verifyAuthCode } from './verifyAuthCode';
-export const auth = {
-    refreshAuth,
-    sendAuthCode,
-    verifyAuthCode,
-};

package/dist/sdk/endpoints/public/auth/refreshAuth.d.ts

@@ -1,41 +0,0 @@
-import * as v from 'valibot';
-export declare const refreshAuth: import("../../../..").EndpointConfig<"/v1/pb/auth/refresh", v.ObjectSchema<{
-    readonly refreshToken: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-}, undefined>, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
-        readonly issues: v.ObjectSchema<{
-            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<400, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<502, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly accessToken: v.StringSchema<undefined>;
-        readonly refreshToken: v.StringSchema<undefined>;
-        readonly user: v.ObjectSchema<{
-            readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-            readonly emailVerified: v.BooleanSchema<undefined>;
-            readonly firstName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly lastName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly profilePictureUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=refreshAuth.d.ts.map

package/dist/sdk/endpoints/public/auth/refreshAuth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"refreshAuth.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/refreshAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA4BtB,CAAA"}