@marcoappio/marco-config 2.0.599 → 3.0.1

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEmailMessageAttachment.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAS5B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;2BAYpC,CAAA"}

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.js

@@ -1,16 +0,0 @@
-import * as v from 'valibot';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { attachmentNotFoundErrorSchema, attachmentStateInvalidErrorSchema, authFailedErrorSchema, } from '../../../../sdk/validation/errors';
-export const getEmailMessageAttachment = createEndpoint({
-    method: 'GET',
-    path: '/v1/pv/attachment/:attachmentId',
-    response: v.union([
-        authFailedErrorSchema,
-        attachmentNotFoundErrorSchema,
-        attachmentStateInvalidErrorSchema,
-        v.object({
-            file: v.nonOptional(v.file()),
-            status: v.literal(200),
-        }),
-    ]),
-});

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

@@ -1,22 +0,0 @@
-export declare const emailMessage: {
-    getAttachment: import("../../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", 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 data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"ATTACHMENT_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<"ATTACHMENT_STATE_INVALID", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<409, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly file: import("valibot").NonOptionalSchema<import("valibot").FileSchema<undefined>, undefined>;
-        readonly status: import("valibot").LiteralSchema<200, undefined>;
-    }, undefined>], undefined>>;
-};
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,4 +0,0 @@
-import { getEmailMessageAttachment } from './getEmailMessageAttachment';
-export const emailMessage = {
-    getAttachment: getEmailMessageAttachment,
-};

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

@@ -1,156 +0,0 @@
-export declare const privateGroup: {
-    draftAttachment: {
-        upload: import("../../..").EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", import("valibot").BlobSchema<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 data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"ATTACHMENT_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<"ATTACHMENT_STATE_INVALID", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<409, undefined>;
-        }, undefined>, 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 status: import("valibot").LiteralSchema<200, undefined>;
-        }, undefined>], undefined>>;
-    };
-    emailMessage: {
-        getAttachment: import("../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", 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 data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"ATTACHMENT_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<"ATTACHMENT_STATE_INVALID", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<409, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly file: import("valibot").NonOptionalSchema<import("valibot").FileSchema<undefined>, undefined>;
-            readonly status: import("valibot").LiteralSchema<200, undefined>;
-        }, undefined>], undefined>>;
-    };
-    models: {
-        account: typeof import("./models/account");
-        contact: typeof import("./models/contact");
-        draft: typeof import("./models/draft");
-        thread: typeof import("./models/thread");
-        user: typeof import("./models/user");
-    };
-    mutations: {
-        account: typeof import("./mutations/account");
-        draft: typeof import("./mutations/draft");
-        thread: typeof import("./mutations/thread");
-        user: typeof import("./mutations/user");
-    };
-    user: {
-        createBillingPortalSession: import("../../..").EndpointConfig<"/v1/pv/user/create-billing-portal-session", import("valibot").ObjectSchema<{
-            readonly returnUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-        }, 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 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<"SUBSCRIPTION_NOT_FOUND", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<404, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly url: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<200, undefined>;
-        }, undefined>], undefined>>;
-        createCheckoutSession: import("../../..").EndpointConfig<"/v1/pv/user/create-checkout-session", import("valibot").ObjectSchema<{
-            readonly cancelUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
-            readonly priceId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
-            readonly successUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
-        }, 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 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 url: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<200, undefined>;
-        }, undefined>], undefined>>;
-        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>>;
-        uploadProfilePicture: import("../../..").EndpointConfig<"/v1/pv/user/profile-picture", import("valibot").BlobSchema<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 data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"FILE_TOO_LARGE", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<413, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"INVALID_FILE_TYPE", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<415, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"INVALID_IMAGE_DIMENSIONS", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<415, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly profilePicture: import("valibot").StringSchema<undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<200, undefined>;
-        }, undefined>], undefined>>;
-    };
-};
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,12 +0,0 @@
-import { draftAttachment } from './draftAttachment';
-import { emailMessage } from './emailMessage';
-import { models } from './models';
-import { mutations } from './mutations';
-import { user } from './user';
-export const privateGroup = {
-    draftAttachment,
-    emailMessage,
-    models,
-    mutations,
-    user,
-};

package/dist/sdk/endpoints/private/models/account/getAccounts.d.ts

@@ -1,70 +0,0 @@
-import * as v from 'valibot';
-export declare const getAccounts: import("../../../../..").EndpointConfig<"/v1/pv/models/accounts/list", v.GenericSchema | undefined, v.ObjectSchema<{
-    readonly cursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly ids: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly include: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly labelIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-    readonly search: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-}, 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 data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
-}, undefined>, 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 items: v.ArraySchema<v.ObjectSchema<{
-            readonly aliases: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
-                readonly emailAddress: 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>, v.BrandAction<string, "AliasId">]>, undefined>;
-                readonly isPrimary: v.BooleanSchema<undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly signature: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 50000, undefined>]>, undefined>;
-            }, undefined>, undefined>, undefined>;
-            readonly color: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly displayName: 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>, v.BrandAction<string, "AccountId">]>, undefined>;
-            readonly imapConnectionStatus: v.PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "CONNECTION_FAILED_AUTHENTICATION_ERROR", "CONNECTION_FAILED_CONNECTION_ERROR", "CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", "CONNECTION_FAILED_QUOTA_ERROR", "CONNECTION_FAILED_UNKNOWN_ERROR"], undefined>;
-            readonly labels: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
-                readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "LabelId">]>, undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly path: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly specialUse: v.NullableSchema<v.PicklistSchema<readonly ["ARCHIVE", "INBOX", "SENT", "SPAM", "TRASH"], undefined>, undefined>;
-                readonly uidValidity: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                readonly unreadCount: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            }, undefined>, undefined>, undefined>;
-            readonly mailProcessedCount: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            readonly mailTotalCount: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            readonly primaryAlias: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
-                readonly emailAddress: 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>, v.BrandAction<string, "AliasId">]>, undefined>;
-                readonly isPrimary: v.BooleanSchema<undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly signature: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 50000, undefined>]>, undefined>;
-            }, undefined>, undefined>, undefined>;
-            readonly primaryAliasId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>;
-            readonly userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
-        }, undefined>, undefined>;
-        readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=getAccounts.d.ts.map

package/dist/sdk/endpoints/private/models/account/getAccounts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getAccounts.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/account/getAccounts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAW5B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoBtB,CAAA"}

package/dist/sdk/endpoints/private/models/account/getAccounts.js

@@ -1,26 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../../schemas';
-import { paginatedResponseSchema } from '../../../../../schemas/paginatedResponse';
-import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { authFailedErrorSchema, userNotFoundErrorSchema, validationFailedErrorSchema, } from '../../../../../sdk/validation/errors';
-export const getAccounts = createEndpoint({
-    method: 'GET',
-    path: '/v1/pv/models/accounts/list',
-    query: v.object({
-        cursor: v.optional(v.string()),
-        ids: v.optional(v.array(v.string())),
-        include: v.optional(v.array(v.string())),
-        labelIds: v.optional(v.array(v.string())),
-        limit: v.optional(marcoSchemas.number.positiveIntegerFromString()),
-        search: v.optional(v.string()),
-    }),
-    response: v.union([
-        authFailedErrorSchema,
-        userNotFoundErrorSchema,
-        validationFailedErrorSchema,
-        v.object({
-            data: paginatedResponseSchema(marcoSchemas.models.accountSchema),
-            status: v.literal(200),
-        }),
-    ]),
-});

package/dist/sdk/endpoints/private/models/account/index.d.ts

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

package/dist/sdk/endpoints/private/models/account/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/account/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/sdk/endpoints/private/models/account/index.js

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

package/dist/sdk/endpoints/private/models/contact/getContacts.d.ts

@@ -1,41 +0,0 @@
-import * as v from 'valibot';
-export declare const getContacts: import("../../../../..").EndpointConfig<"/v1/pv/models/contacts/list", v.GenericSchema | undefined, v.ObjectSchema<{
-    readonly cursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly emailAddresses: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly ids: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-    readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly search: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-}, 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 data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
-}, undefined>, 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 items: v.ArraySchema<v.ObjectSchema<{
-            readonly emailAddress: 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>, v.BrandAction<string, "ContactId">]>, undefined>;
-            readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
-        }, undefined>, undefined>;
-        readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=getContacts.d.ts.map

package/dist/sdk/endpoints/private/models/contact/getContacts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getContacts.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/contact/getContacts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAW5B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoBtB,CAAA"}

package/dist/sdk/endpoints/private/models/contact/getContacts.js

@@ -1,26 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../../schemas';
-import { paginatedResponseSchema } from '../../../../../schemas/paginatedResponse';
-import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { authFailedErrorSchema, userNotFoundErrorSchema, validationFailedErrorSchema, } from '../../../../../sdk/validation/errors';
-export const getContacts = createEndpoint({
-    method: 'GET',
-    path: '/v1/pv/models/contacts/list',
-    query: v.object({
-        cursor: v.optional(v.string()),
-        emailAddresses: v.optional(v.array(v.string())),
-        ids: v.optional(v.array(v.string())),
-        limit: v.optional(marcoSchemas.number.positiveIntegerFromString()),
-        name: v.optional(v.string()),
-        search: v.optional(v.string()),
-    }),
-    response: v.union([
-        authFailedErrorSchema,
-        userNotFoundErrorSchema,
-        validationFailedErrorSchema,
-        v.object({
-            data: paginatedResponseSchema(marcoSchemas.models.contactSchema),
-            status: v.literal(200),
-        }),
-    ]),
-});

package/dist/sdk/endpoints/private/models/contact/index.d.ts

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

package/dist/sdk/endpoints/private/models/contact/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/contact/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/sdk/endpoints/private/models/contact/index.js

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

package/dist/sdk/endpoints/private/models/draft/getDrafts.d.ts

@@ -1,62 +0,0 @@
-import * as v from 'valibot';
-export declare const getDrafts: import("../../../../../types").EndpointConfig<"/v1/pv/models/drafts/list", v.GenericSchema | undefined, v.ObjectSchema<{
-    readonly accountId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly cursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-    readonly status: v.OptionalSchema<v.PicklistSchema<readonly ["DRAFT", "SEND_REQUESTED", "SEND_IN_PROGRESS", "SEND_CONFIRMED", "SEND_FAILED"], undefined>, undefined>;
-}, 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 data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
-}, undefined>, 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 items: v.ArraySchema<v.ObjectSchema<{
-            readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
-            readonly attachments: v.ArraySchema<v.ObjectSchema<{
-                readonly draftId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "DraftId">]>, undefined>;
-                readonly fileName: 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>, v.BrandAction<string, "AttachmentId">]>, undefined>;
-                readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly status: v.PicklistSchema<readonly ["PENDING", "COMPLETE", "FAILED"], undefined>;
-                readonly totalSize: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            }, undefined>, undefined>;
-            readonly body: v.ObjectSchema<{
-                readonly bcc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                readonly cc: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-                readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 384000, undefined>]>;
-                readonly to: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-            }, undefined>;
-            readonly error: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly fromAliasId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AliasId">]>, undefined>;
-            readonly fromEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly fromName: 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>, v.BrandAction<string, "DraftId">]>, undefined>;
-            readonly referencedMessageId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
-            readonly scheduledFor: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-            readonly status: v.PicklistSchema<readonly ["DRAFT", "SEND_REQUESTED", "SEND_IN_PROGRESS", "SEND_CONFIRMED", "SEND_FAILED"], undefined>;
-            readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly type: v.PicklistSchema<readonly ["NEW", "REPLY", "FORWARD"], undefined>;
-            readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            readonly userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
-        }, undefined>, undefined>;
-        readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=getDrafts.d.ts.map

package/dist/sdk/endpoints/private/models/draft/getDrafts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getDrafts.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/draft/getDrafts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAY5B,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAkBpB,CAAA"}

package/dist/sdk/endpoints/private/models/draft/getDrafts.js

@@ -1,25 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../../schemas';
-import { paginatedResponseSchema } from '../../../../../schemas/paginatedResponse';
-import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { authFailedErrorSchema, userNotFoundErrorSchema, validationFailedErrorSchema, } from '../../../../../sdk/validation/errors';
-import { DRAFT_STATUSES } from '../../../../../types';
-export const getDrafts = createEndpoint({
-    method: 'GET',
-    path: '/v1/pv/models/drafts/list',
-    query: v.object({
-        accountId: v.optional(v.string()),
-        cursor: v.optional(v.string()),
-        limit: v.optional(marcoSchemas.number.positiveIntegerFromString()),
-        status: v.optional(v.picklist(DRAFT_STATUSES)),
-    }),
-    response: v.union([
-        authFailedErrorSchema,
-        userNotFoundErrorSchema,
-        validationFailedErrorSchema,
-        v.object({
-            data: paginatedResponseSchema(marcoSchemas.models.draftSchema),
-            status: v.literal(200),
-        }),
-    ]),
-});

package/dist/sdk/endpoints/private/models/draft/index.d.ts

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

package/dist/sdk/endpoints/private/models/draft/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/draft/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA"}

package/dist/sdk/endpoints/private/models/draft/index.js

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

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

@@ -1,13 +0,0 @@
-import * as account from './account';
-import * as contact from './contact';
-import * as draft from './draft';
-import * as thread from './thread';
-import * as user from './user';
-export declare const models: {
-    account: typeof account;
-    contact: typeof contact;
-    draft: typeof draft;
-    thread: typeof thread;
-    user: typeof user;
-};
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/models/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA;AAE9B,eAAO,MAAM,MAAM;;;;;;CAMlB,CAAA"}

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

@@ -1,12 +0,0 @@
-import * as account from './account';
-import * as contact from './contact';
-import * as draft from './draft';
-import * as thread from './thread';
-import * as user from './user';
-export const models = {
-    account,
-    contact,
-    draft,
-    thread,
-    user,
-};