@marcoappio/marco-config 11.0.11 → 11.0.13

package/dist/schemas/index.d.ts

@@ -732,57 +732,57 @@ export declare const marcoSchemas: {
         };
         thread: {
             addLabel: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
                 readonly labelPath: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             }, undefined>;
             delete: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
             }, undefined>;
             removeLabel: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
                 readonly labelPath: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             }, undefined>;
             setArchive: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
             }, undefined>;
             setFlagged: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
                 readonly flagged: import("valibot").BooleanSchema<undefined>;
             }, undefined>;
             setInbox: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
             }, undefined>;
             setSeen: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
                 readonly seen: import("valibot").BooleanSchema<undefined>;
             }, undefined>;
             setSnooze: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
                 readonly snoozedUntil: import("valibot").NullableSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
             }, undefined>;
             setSpam: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
             }, undefined>;
             setTrash: import("valibot").ObjectSchema<{
-                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, import("valibot").ObjectSchema<{
+                readonly accounts: import("valibot").RecordSchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>, import("valibot").ObjectSchema<{
                     readonly threadIds: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ThreadId">]>, undefined>, undefined>;
                 }, undefined>, undefined>;
             }, undefined>;

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

@@ -256,57 +256,57 @@ export declare const mutatorSchemas: {
     };
     thread: {
         addLabel: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
             readonly labelPath: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
         delete: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>;
         removeLabel: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
             readonly labelPath: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
         setArchive: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>;
         setFlagged: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
             readonly flagged: v.BooleanSchema<undefined>;
         }, undefined>;
         setInbox: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>;
         setSeen: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
             readonly seen: v.BooleanSchema<undefined>;
         }, undefined>;
         setSnooze: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
             readonly snoozedUntil: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
         }, undefined>;
         setSpam: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>;
         setTrash: v.ObjectSchema<{
-            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.ObjectSchema<{
+            readonly accounts: v.RecordSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>, v.ObjectSchema<{
                 readonly threadIds: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>;

package/dist/schemas/mutators/mutatorSchemas.js

@@ -11,7 +11,7 @@ const accountAliasSchema = v.object({
     id: id.aliasId.required(),
     name: string.nullable(),
 });
-const accountsSchema = v.record(string.required(), v.object({
+const accountsSchema = v.record(id.accountId.required(), v.object({
     threadIds: v.array(id.threadId.required()),
 }));
 const baseThreadSchema = v.object({

package/dist/sdk/endpoints/createEndpointConfig.d.ts

@@ -1,12 +1,18 @@
-import type { GenericSchema } from 'valibot';
+import * as v from 'valibot';
+import { regionNotSupportedErrorSchema } from '../../sdk/validation/errors';
 import type { BodyType, EndpointConfig, HTTPMethod, SDKResponse, URLPattern } from '../../types/Endpoint';
 export declare const createURLPattern: <T extends string>(pattern: T) => (params: URLPattern<T>) => string;
-export declare const createEndpoint: <TPath extends string, TRequestBody extends GenericSchema | undefined, TRequestQuery extends GenericSchema | undefined, TResponse extends GenericSchema<SDKResponse>>(params: {
+type EndpointResponse<TResponse extends v.GenericSchema<SDKResponse>> = v.UnionSchema<[
+    TResponse,
+    typeof regionNotSupportedErrorSchema
+], undefined>;
+export declare const createEndpoint: <TPath extends string, TRequestBody extends v.GenericSchema | undefined, TRequestQuery extends v.GenericSchema | undefined, TResponse extends v.GenericSchema<SDKResponse>>(params: {
     body?: TRequestBody;
     bodyType?: BodyType;
     method: HTTPMethod;
     path: TPath;
     query?: TRequestQuery;
     response: TResponse;
-}) => EndpointConfig<TPath, TRequestBody, TRequestQuery, TResponse>;
+}) => EndpointConfig<TPath, TRequestBody, TRequestQuery, EndpointResponse<TResponse>>;
+export {};
 //# sourceMappingURL=createEndpointConfig.d.ts.map

package/dist/sdk/endpoints/createEndpointConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createEndpointConfig.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/createEndpointConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAEjH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,SAAS,MAAM,WAAW,CAAC,cACpB,UAAU,CAAC,CAAC,CAAC,KAAG,MAWxB,CAAA;AAEH,eAAO,MAAM,cAAc,GACzB,KAAK,SAAS,MAAM,EACpB,YAAY,SAAS,aAAa,GAAG,SAAS,EAC9C,aAAa,SAAS,aAAa,GAAG,SAAS,EAC/C,SAAS,SAAS,aAAa,CAAC,WAAW,CAAC,UACpC;IACR,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,KAAK,CAAA;IACX,KAAK,CAAC,EAAE,aAAa,CAAA;IACrB,QAAQ,EAAE,SAAS,CAAA;CACpB,KAAG,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,CAQ9D,CAAA"}
+{"version":3,"file":"createEndpointConfig.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/createEndpointConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAA;AACnF,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAEjH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,SAAS,MAAM,WAAW,CAAC,cACpB,UAAU,CAAC,CAAC,CAAC,KAAG,MAWxB,CAAA;AAGH,KAAK,gBAAgB,CAAC,SAAS,SAAS,CAAC,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,WAAW,CACnF;IAAC,SAAS;IAAE,OAAO,6BAA6B;CAAC,EACjD,SAAS,CACV,CAAA;AAED,eAAO,MAAM,cAAc,GACzB,KAAK,SAAS,MAAM,EACpB,YAAY,SAAS,CAAC,CAAC,aAAa,GAAG,SAAS,EAChD,aAAa,SAAS,CAAC,CAAC,aAAa,GAAG,SAAS,EACjD,SAAS,SAAS,CAAC,CAAC,aAAa,CAAC,WAAW,CAAC,UACtC;IACR,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,KAAK,CAAA;IACX,KAAK,CAAC,EAAE,aAAa,CAAA;IACrB,QAAQ,EAAE,SAAS,CAAA;CACpB,KAAG,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAQhF,CAAA"}

package/dist/sdk/endpoints/createEndpointConfig.js

@@ -1,3 +1,5 @@
+import * as v from 'valibot';
+import { regionNotSupportedErrorSchema } from '../../sdk/validation/errors';
 export const createURLPattern = (pattern) => (params) => {
     const segments = pattern.split('/');
     return segments
@@ -17,5 +19,5 @@ export const createEndpoint = (params) => ({
     method: params.method,
     path: params.path,
     query: params.query,
-    response: params.response,
+    response: v.union([params.response, regionNotSupportedErrorSchema]),
 });

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

@@ -3,7 +3,7 @@ import type { EndpointConfig } from '../../types';
 export declare const endpoints: {
     private: {
         draftAttachment: {
-            upload: EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", import("valibot").BlobSchema<undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            upload: EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", import("valibot").BlobSchema<undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
                 }, undefined>;
@@ -40,10 +40,15 @@ export declare const endpoints: {
                 readonly status: import("valibot").LiteralSchema<400, undefined>;
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<403, undefined>;
             }, undefined>], undefined>>;
         };
         emailMessage: {
-            getAttachment: EndpointConfig<"/v1/pv/attachment/:attachmentId", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            getAttachment: EndpointConfig<"/v1/pv/attachment/:attachmentId", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
                 }, undefined>;
@@ -61,6 +66,11 @@ export declare const endpoints: {
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly file: import("valibot").NonOptionalSchema<import("valibot").FileSchema<undefined>, undefined>;
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<403, undefined>;
             }, undefined>], undefined>>;
         };
         models: {
@@ -79,15 +89,20 @@ export declare const endpoints: {
             user: typeof import("./private/mutations/user");
         };
         user: {
-            deleteUser: EndpointConfig<"/v1/pv/user", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            deleteUser: EndpointConfig<"/v1/pv/user", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[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>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<403, undefined>;
             }, undefined>], undefined>>;
-            uploadProfilePicture: EndpointConfig<"/v1/pv/user/profile-picture", import("valibot").BlobSchema<undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            uploadProfilePicture: EndpointConfig<"/v1/pv/user/profile-picture", import("valibot").BlobSchema<undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
                 }, undefined>;
@@ -112,6 +127,11 @@ export declare const endpoints: {
                     readonly profilePicture: import("valibot").StringSchema<undefined>;
                 }, undefined>;
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<403, undefined>;
             }, undefined>], undefined>>;
         };
     };
@@ -120,7 +140,7 @@ export declare const endpoints: {
             browser: {
                 deleteSession: EndpointConfig<"/v1/pb/auth/browser/session", GenericSchema | undefined, import("valibot").StrictObjectSchema<{
                     readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
-                }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                }, undefined>, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
                     readonly data: import("valibot").StrictObjectSchema<{
                         readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                         readonly issues: import("valibot").ObjectSchema<{
@@ -137,10 +157,15 @@ export declare const endpoints: {
                     readonly status: import("valibot").LiteralSchema<502, undefined>;
                 }, undefined>, import("valibot").StrictObjectSchema<{
                     readonly status: import("valibot").LiteralSchema<204, undefined>;
+                }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<403, undefined>;
                 }, undefined>], undefined>>;
                 refreshAuth: EndpointConfig<"/v1/pb/auth/browser/refresh", GenericSchema | undefined, import("valibot").StrictObjectSchema<{
                     readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
-                }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                }, undefined>, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
                     readonly data: import("valibot").StrictObjectSchema<{
                         readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                         readonly issues: import("valibot").ObjectSchema<{
@@ -175,6 +200,11 @@ export declare const endpoints: {
                         }, undefined>;
                     }, undefined>;
                     readonly status: import("valibot").LiteralSchema<200, undefined>;
+                }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<403, undefined>;
                 }, undefined>], undefined>>;
                 verifyAuthCode: EndpointConfig<"/v1/pb/auth/browser/verify-code", import("valibot").ObjectSchema<{
                     readonly authType: import("valibot").LiteralSchema<"CODE", undefined>;
@@ -182,7 +212,7 @@ export declare const endpoints: {
                     readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
                 }, undefined>, import("valibot").StrictObjectSchema<{
                     readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
-                }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                }, undefined>, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
                     readonly data: import("valibot").StrictObjectSchema<{
                         readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                         readonly issues: import("valibot").ObjectSchema<{
@@ -242,11 +272,16 @@ export declare const endpoints: {
                         }, undefined>;
                     }, undefined>;
                     readonly status: import("valibot").LiteralSchema<200, undefined>;
+                }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<403, undefined>;
                 }, undefined>], undefined>>;
             };
             refreshAuth: 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>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            }, undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                     readonly issues: import("valibot").ObjectSchema<{
@@ -282,10 +317,15 @@ export declare const endpoints: {
                     }, undefined>;
                 }, undefined>;
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<403, undefined>;
             }, undefined>], undefined>>;
             revokeSession: EndpointConfig<"/v1/pb/auth/session/revoke", import("valibot").StrictObjectSchema<{
                 readonly accessToken: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            }, undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            }, undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                     readonly issues: import("valibot").ObjectSchema<{
@@ -307,10 +347,15 @@ export declare const endpoints: {
                 readonly status: import("valibot").LiteralSchema<502, undefined>;
             }, undefined>, import("valibot").StrictObjectSchema<{
                 readonly status: import("valibot").LiteralSchema<204, undefined>;
+            }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<403, undefined>;
             }, undefined>], undefined>>;
             sendAuthCode: EndpointConfig<"/v1/pb/auth/send-code", import("valibot").ObjectSchema<{
                 readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
-            }, undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            }, undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                     readonly issues: import("valibot").ObjectSchema<{
@@ -332,12 +377,17 @@ export declare const endpoints: {
                 readonly status: import("valibot").LiteralSchema<404, undefined>;
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<403, undefined>;
             }, undefined>], undefined>>;
             verifyAuthCode: EndpointConfig<"/v1/pb/auth/verify-code", 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").RfcEmailAction<string, undefined>]>, undefined>;
-            }, undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            }, undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
                     readonly issues: import("valibot").ObjectSchema<{
@@ -398,22 +448,37 @@ export declare const endpoints: {
                     }, undefined>;
                 }, undefined>;
                 readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<403, undefined>;
             }, undefined>], undefined>>;
         };
-        config: EndpointConfig<"/v1/pb/config", GenericSchema | undefined, GenericSchema | undefined, import("valibot").ObjectSchema<{
+        config: EndpointConfig<"/v1/pb/config", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly app: import("valibot").ObjectSchema<{
                     readonly minimumVersion: 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>>;
-        healthcheck: EndpointConfig<"/v1/pb/healthcheck", GenericSchema | undefined, GenericSchema | undefined, import("valibot").ObjectSchema<{
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<403, undefined>;
+        }, undefined>], undefined>>;
+        healthcheck: EndpointConfig<"/v1/pb/healthcheck", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly status: import("valibot").LiteralSchema<"ok", undefined>;
             }, undefined>;
             readonly status: import("valibot").LiteralSchema<200, undefined>;
-        }, undefined>>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<403, undefined>;
+        }, undefined>], undefined>>;
     };
 };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,qBAAqB,CAAA;AAWtE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,qBAAqB,CAAA;AAWtE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}

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

@@ -1,5 +1,5 @@
 export declare const draftAttachment: {
-    upload: import("../../../..").EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", import("valibot").BlobSchema<undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+    upload: import("../../../..").EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", import("valibot").BlobSchema<undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
         readonly data: import("valibot").ObjectSchema<{
             readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
         }, undefined>;
@@ -36,6 +36,11 @@ export declare const draftAttachment: {
         readonly status: import("valibot").LiteralSchema<400, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
         readonly status: import("valibot").LiteralSchema<200, undefined>;
+    }, undefined>], undefined>, import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<403, undefined>;
     }, undefined>], undefined>>;
 };
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/sdk/endpoints/private/draftAttachment/uploadDraftAttachment.d.ts

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const uploadDraftAttachment: import("../../../..").EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", v.BlobSchema<undefined>, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
+export declare const uploadDraftAttachment: import("../../../..").EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", v.BlobSchema<undefined>, v.GenericSchema | undefined, v.UnionSchema<[v.UnionSchema<[v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
     }, undefined>;
@@ -36,5 +36,10 @@ export declare const uploadDraftAttachment: import("../../../..").EndpointConfig
     readonly status: v.LiteralSchema<400, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<403, undefined>;
 }, undefined>], undefined>>;
 //# sourceMappingURL=uploadDraftAttachment.d.ts.map

package/dist/sdk/endpoints/private/draftAttachment/uploadDraftAttachment.d.ts.map

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

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

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-export declare const getEmailMessageAttachment: import("../../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", v.GenericSchema | undefined, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
+export declare const getEmailMessageAttachment: import("../../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", v.GenericSchema | undefined, v.GenericSchema | undefined, v.UnionSchema<[v.UnionSchema<[v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
     }, undefined>;
@@ -17,5 +17,10 @@ export declare const getEmailMessageAttachment: import("../../../..").EndpointCo
 }, undefined>, v.ObjectSchema<{
     readonly file: v.NonOptionalSchema<v.FileSchema<undefined>, undefined>;
     readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<403, undefined>;
 }, undefined>], undefined>>;
 //# sourceMappingURL=getEmailMessageAttachment.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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/index.d.ts

@@ -1,5 +1,5 @@
 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<{
+    getAttachment: import("../../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
         readonly data: import("valibot").ObjectSchema<{
             readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
         }, undefined>;
@@ -17,6 +17,11 @@ export declare const emailMessage: {
     }, undefined>, import("valibot").ObjectSchema<{
         readonly file: import("valibot").NonOptionalSchema<import("valibot").FileSchema<undefined>, undefined>;
         readonly status: import("valibot").LiteralSchema<200, undefined>;
+    }, undefined>], undefined>, import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"REGION_NOT_SUPPORTED", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<403, undefined>;
     }, undefined>], undefined>>;
 };
 //# sourceMappingURL=index.d.ts.map

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

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