@amityco/ts-sdk 7.29.0 → 7.29.1-cc0fba8.0

package/dist/messageRepository/api/flagMessage.d.ts

@@ -1,15 +1,82 @@
+declare type FlagMessage = {
+    /**
+     * ```js
+     * import { MessageRepository } from '@amityco/ts-sdk'
+     * const flagged = await MessageRepository.flagMessage(messageId)
+     * ```
+     *
+     * Flags a message without a reason. The report is sent as `Others`; no detail is serialized.
+     *
+     * @param messageId The ID of the message to flag
+     * @returns `true` when the report was created
+     */
+    (messageId: Amity.Message['messageId'], reason?: undefined): Promise<boolean>;
+    /**
+     * ```js
+     * import { MessageRepository, ContentFlagReasonEnum } from '@amityco/ts-sdk'
+     * const flagged = await MessageRepository.flagMessage(messageId, {
+     *   reason: ContentFlagReasonEnum.SpamOrScams,
+     *   detail: 'Repeated promotional links',
+     * })
+     * ```
+     *
+     * Flags a message with a category and optional reporter context. Any category,
+     * including `Others`, may carry a `detail`. `detail` is sent unchanged and omitted
+     * when not supplied; the backend enforces its 300-character limit.
+     *
+     * @param messageId The ID of the message to flag
+     * @param options `reason` is a `ContentFlagReasonEnum` value; `detail` is optional free text
+     * @returns `true` when the report was created
+     * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when `options` is malformed, before any request is made
+     */
+    (messageId: Amity.Message['messageId'], options: Amity.ContentFlagOptions): Promise<boolean>;
+    /**
+     * ```js
+     * import { MessageRepository } from '@amityco/ts-sdk'
+     * const flagged = await MessageRepository.flagMessage(messageId, reason)
+     * ```
+     *
+     * @deprecated Pass an options object instead: `flagMessage(messageId, { reason, detail })`.
+     * A predefined string maps to `{ reason: <value>, detail: '' }`; a custom string maps to
+     * `{ reason: 'Others', detail: <string> }`. Migrate a custom string to
+     * `{ reason: ContentFlagReasonEnum.Others, detail: customString }`. This mapping is
+     * unchanged and stays available throughout the current major version.
+     *
+     * @param messageId The ID of the message to flag
+     * @param reason a predefined `ContentFlagReasonEnum` value or a custom string
+     * @returns `true` when the report was created
+     */
+    (messageId: Amity.Message['messageId'], reason?: Amity.ContentFlagReason): Promise<boolean>;
+};
 /**
  * ```js
- * import { MessageRepository } from '@amityco/ts-sdk'
- * const flagged = await MessageRepository.flagMessage(messageId, reason)
+ * import { MessageRepository, ContentFlagReasonEnum } from '@amityco/ts-sdk'
+ *
+ * // No reason.
+ * await MessageRepository.flagMessage(messageId)
+ *
+ * // Category plus optional reporter context (any category, including Others).
+ * await MessageRepository.flagMessage(messageId, {
+ *   reason: ContentFlagReasonEnum.SpamOrScams,
+ *   detail: 'Repeated promotional links',
+ * })
  * ```
  *
- * @param messageId of the message to flag
- * @param reason the reason to flag the message
- * @returns the created report result
+ * Reports a message to moderation. Three call shapes are accepted (see the overloads):
+ * id-only, an options object, and the deprecated legacy reason string. The public
+ * name only dispatches on the input shape; the two implementations are kept separate
+ * so the legacy path is untouched by the new contract:
+ *
+ * - `undefined` or a string → `flagMessageWithReasonString` (unchanged legacy mapping)
+ * - anything else → `flagMessageWithOptions` (validated `{ reason, detail? }`)
+ *
+ * @param messageId The ID of the message to flag
+ * @param input an options object `{ reason, detail? }`, a legacy reason string, or nothing
+ * @returns `true` when the report was created
  *
  * @category Message API
  * @async
  * */
-export declare const flagMessage: (messageId: Amity.Message['messageId'], reason?: Amity.ContentFlagReason) => Promise<boolean>;
+export declare const flagMessage: FlagMessage;
+export {};
 //# sourceMappingURL=flagMessage.d.ts.map

package/dist/messageRepository/api/flagMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flagMessage.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/api/flagMessage.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;KAYK;AACL,eAAO,MAAM,WAAW,cACX,MAAM,OAAO,CAAC,WAAW,CAAC,WAC5B,MAAM,iBAAiB,KAC/B,QAAQ,OAAO,CA4BjB,CAAC"}
+{"version":3,"file":"flagMessage.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/api/flagMessage.ts"],"names":[],"mappings":"AAIA,aAAK,WAAW,GAAG;IACjB;;;;;;;;;;OAUG;IACH,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9E;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7F;;;;;;;;;;;;;;;OAeG;IACH,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7F,CAAC;AAKF;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4BK;AACL,eAAO,MAAM,WAAW,EAAE,WAMoB,CAAC"}

package/dist/messageRepository/api/tests/integration/flagMessage.overloads.integration.test.d.ts

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

package/dist/messageRepository/api/tests/integration/flagMessage.overloads.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagMessage.overloads.integration.test.d.ts","sourceRoot":"","sources":["../../../../../src/messageRepository/api/tests/integration/flagMessage.overloads.integration.test.ts"],"names":[],"mappings":""}

package/dist/messageRepository/internalApi/flagMessageWithOptions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * New `flagMessage(messageId, { reason, detail? })` implementation. Any category,
+ * including `Others`, may carry a `detail`. `detail` is forwarded unchanged (empty and
+ * whitespace-only strings included) and omitted from the request body when `undefined`;
+ * the backend enforces the 300-character limit.
+ *
+ * Not exported from the public API. It is reached through the
+ * `MessageRepository.flagMessage(messageId, options)` overload; see `api/flagMessage.ts`.
+ *
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when `options` is malformed, before any request is made
+ */
+export declare const flagMessageWithOptions: (messageId: Amity.Message['messageId'], options: Amity.ContentFlagOptions) => Promise<boolean>;
+//# sourceMappingURL=flagMessageWithOptions.d.ts.map

package/dist/messageRepository/internalApi/flagMessageWithOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagMessageWithOptions.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/internalApi/flagMessageWithOptions.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,cACtB,MAAM,OAAO,CAAC,WAAW,CAAC,WAC5B,MAAM,kBAAkB,KAChC,QAAQ,OAAO,CAqBjB,CAAC"}

package/dist/messageRepository/internalApi/flagMessageWithReasonString.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Legacy `flagMessage(messageId, reason?)` implementation, kept verbatim so existing
+ * callers keep the exact request body they had before the options contract existed:
+ *
+ * - predefined `ContentFlagReasonEnum` value → `{ reason: <value>, detail: '' }`
+ * - any other non-empty string (including the literal `'Others'`) → `{ reason: 'Others', detail: <string> }`
+ * - `undefined` or `''` → `{ reason: 'Others', detail: '' }`
+ *   (for `undefined` the message body carries `detail: undefined`, which JSON serialization omits)
+ *
+ * Not exported from the public API. It is reached through the deprecated
+ * `MessageRepository.flagMessage(messageId, reason)` overload; see `api/flagMessage.ts`.
+ *
+ * Not itself deprecated: it implements the deprecated legacy-string overload of the public
+ * `flagMessage`, which carries the deprecation tag. New code should use `flagMessageWithOptions`
+ * (the `{ reason, detail? }` contract). This path stays available throughout the current major version.
+ */
+export declare const flagMessageWithReasonString: (messageId: Amity.Message['messageId'], reason?: Amity.ContentFlagReason) => Promise<boolean>;
+//# sourceMappingURL=flagMessageWithReasonString.d.ts.map

package/dist/messageRepository/internalApi/flagMessageWithReasonString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagMessageWithReasonString.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/internalApi/flagMessageWithReasonString.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,2BAA2B,cAC3B,MAAM,OAAO,CAAC,WAAW,CAAC,WAC5B,MAAM,iBAAiB,KAC/B,QAAQ,OAAO,CA4BjB,CAAC"}

package/dist/messageRepository/internalApi/tests/integration/flagMessageWithOptions.integration.test.d.ts

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

package/dist/messageRepository/internalApi/tests/integration/flagMessageWithOptions.integration.test.d.ts.map

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

package/dist/messageRepository/internalApi/tests/integration/flagMessageWithReasonString.integration.test.d.ts

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

package/dist/messageRepository/internalApi/tests/integration/flagMessageWithReasonString.integration.test.d.ts.map

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

package/dist/postRepository/api/flagPost.d.ts

@@ -1,15 +1,82 @@
+declare type FlagPost = {
+    /**
+     * ```js
+     * import { PostRepository } from '@amityco/ts-sdk'
+     * const flagged = await PostRepository.flagPost(postId)
+     * ```
+     *
+     * Flags a post without a reason. The report is sent as `Others` with an empty detail.
+     *
+     * @param postId The ID of the post to flag
+     * @returns `true` when the report was created
+     */
+    (postId: Amity.Post['postId'], reason?: undefined): Promise<boolean>;
+    /**
+     * ```js
+     * import { PostRepository, ContentFlagReasonEnum } from '@amityco/ts-sdk'
+     * const flagged = await PostRepository.flagPost(postId, {
+     *   reason: ContentFlagReasonEnum.SpamOrScams,
+     *   detail: 'Repeated promotional links',
+     * })
+     * ```
+     *
+     * Flags a post with a category and optional reporter context. Any category,
+     * including `Others`, may carry a `detail`. `detail` is sent unchanged and omitted
+     * when not supplied; the backend enforces its 300-character limit.
+     *
+     * @param postId The ID of the post to flag
+     * @param options `reason` is a `ContentFlagReasonEnum` value; `detail` is optional free text
+     * @returns `true` when the report was created
+     * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when `options` is malformed, before any request is made
+     */
+    (postId: Amity.Post['postId'], options: Amity.ContentFlagOptions): Promise<boolean>;
+    /**
+     * ```js
+     * import { PostRepository } from '@amityco/ts-sdk'
+     * const flagged = await PostRepository.flagPost(postId, reason)
+     * ```
+     *
+     * @deprecated Pass an options object instead: `flagPost(postId, { reason, detail })`.
+     * A predefined string maps to `{ reason: <value>, detail: '' }`; a custom string maps to
+     * `{ reason: 'Others', detail: <string> }`. Migrate a custom string to
+     * `{ reason: ContentFlagReasonEnum.Others, detail: customString }`. This mapping is
+     * unchanged and stays available throughout the current major version.
+     *
+     * @param postId The ID of the post to flag
+     * @param reason a predefined `ContentFlagReasonEnum` value or a custom string
+     * @returns `true` when the report was created
+     */
+    (postId: Amity.Post['postId'], reason?: Amity.ContentFlagReason): Promise<boolean>;
+};
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const flagged = await PostRepository.flagPost(postId, reason)
+ * import { PostRepository, ContentFlagReasonEnum } from '@amityco/ts-sdk'
+ *
+ * // No reason.
+ * await PostRepository.flagPost(postId)
+ *
+ * // Category plus optional reporter context (any category, including Others).
+ * await PostRepository.flagPost(postId, {
+ *   reason: ContentFlagReasonEnum.SpamOrScams,
+ *   detail: 'Repeated promotional links',
+ * })
  * ```
  *
- * @param postId of the post to flag
- * @param reason the reason to flag the post
- * @returns a boolean
+ * Reports a post to moderation. Three call shapes are accepted (see the overloads):
+ * id-only, an options object, and the deprecated legacy reason string. The public
+ * name only dispatches on the input shape; the two implementations are kept separate
+ * so the legacy path is untouched by the new contract:
+ *
+ * - `undefined` or a string → `flagPostWithReasonString` (unchanged legacy mapping)
+ * - anything else → `flagPostWithOptions` (validated `{ reason, detail? }`)
+ *
+ * @param postId The ID of the post to flag
+ * @param input an options object `{ reason, detail? }`, a legacy reason string, or nothing
+ * @returns `true` when the report was created
  *
  * @category Post API
  * @async
  * */
-export declare const flagPost: (postId: Amity.Post['postId'], reason?: Amity.ContentFlagReason) => Promise<boolean>;
+export declare const flagPost: FlagPost;
+export {};
 //# sourceMappingURL=flagPost.d.ts.map

package/dist/postRepository/api/flagPost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flagPost.d.ts","sourceRoot":"","sources":["../../../src/postRepository/api/flagPost.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;KAYK;AACL,eAAO,MAAM,QAAQ,WACX,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,iBAAiB,KAC/B,QAAQ,OAAO,CA2BjB,CAAC"}
+{"version":3,"file":"flagPost.d.ts","sourceRoot":"","sources":["../../../src/postRepository/api/flagPost.ts"],"names":[],"mappings":"AAIA,aAAK,QAAQ,GAAG;IACd;;;;;;;;;;OAUG;IACH,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACrE;;;;;;;;;;;;;;;;;OAiBG;IACH,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACpF;;;;;;;;;;;;;;;OAeG;IACH,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACpF,CAAC;AAKF;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4BK;AACL,eAAO,MAAM,QAAQ,EAAE,QAMiB,CAAC"}

package/dist/postRepository/api/tests/integration/flagPost.overloads.integration.test.d.ts

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

package/dist/postRepository/api/tests/integration/flagPost.overloads.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagPost.overloads.integration.test.d.ts","sourceRoot":"","sources":["../../../../../src/postRepository/api/tests/integration/flagPost.overloads.integration.test.ts"],"names":[],"mappings":""}

package/dist/postRepository/internalApi/flagPostWithOptions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * New `flagPost(postId, { reason, detail? })` implementation. Any category, including
+ * `Others`, may carry a `detail`. `detail` is forwarded unchanged (empty and
+ * whitespace-only strings included) and omitted from the request body when `undefined`;
+ * the backend enforces the 300-character limit.
+ *
+ * Not exported from the public API. It is reached through the
+ * `PostRepository.flagPost(postId, options)` overload; see `api/flagPost.ts`.
+ *
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when `options` is malformed, before any request is made
+ */
+export declare const flagPostWithOptions: (postId: Amity.Post['postId'], options: Amity.ContentFlagOptions) => Promise<boolean>;
+//# sourceMappingURL=flagPostWithOptions.d.ts.map

package/dist/postRepository/internalApi/flagPostWithOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagPostWithOptions.d.ts","sourceRoot":"","sources":["../../../src/postRepository/internalApi/flagPostWithOptions.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,WACtB,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,kBAAkB,KAChC,QAAQ,OAAO,CAoBjB,CAAC"}

package/dist/postRepository/internalApi/flagPostWithReasonString.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Legacy `flagPost(postId, reason?)` implementation, kept verbatim so existing
+ * callers keep the exact request body they had before the options contract existed:
+ *
+ * - predefined `ContentFlagReasonEnum` value → `{ reason: <value>, detail: '' }`
+ * - any other non-empty string (including the literal `'Others'`) → `{ reason: 'Others', detail: <string> }`
+ * - `undefined` or `''` → `{ reason: 'Others', detail: '' }`
+ *
+ * Not exported from the public API. It is reached through the deprecated
+ * `PostRepository.flagPost(postId, reason)` overload; see `api/flagPost.ts`.
+ *
+ * Not itself deprecated: it implements the deprecated legacy-string overload of the public
+ * `flagPost`, which carries the deprecation tag. New code should use `flagPostWithOptions`
+ * (the `{ reason, detail? }` contract). This path stays available throughout the current major version.
+ */
+export declare const flagPostWithReasonString: (postId: Amity.Post['postId'], reason?: Amity.ContentFlagReason) => Promise<boolean>;
+//# sourceMappingURL=flagPostWithReasonString.d.ts.map

package/dist/postRepository/internalApi/flagPostWithReasonString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagPostWithReasonString.d.ts","sourceRoot":"","sources":["../../../src/postRepository/internalApi/flagPostWithReasonString.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,WAC3B,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,iBAAiB,KAC/B,QAAQ,OAAO,CA2BjB,CAAC"}

package/dist/postRepository/internalApi/index.d.ts

@@ -1,2 +1,4 @@
 export * from './getPost';
+export * from './flagPostWithReasonString';
+export * from './flagPostWithOptions';
 //# sourceMappingURL=index.d.ts.map

package/dist/postRepository/internalApi/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/postRepository/internalApi/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/postRepository/internalApi/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAE1B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC"}

package/dist/postRepository/internalApi/tests/integration/flagPostWithOptions.integration.test.d.ts

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

package/dist/postRepository/internalApi/tests/integration/flagPostWithOptions.integration.test.d.ts.map

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

package/dist/postRepository/internalApi/tests/integration/flagPostWithReasonString.integration.test.d.ts

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

package/dist/postRepository/internalApi/tests/integration/flagPostWithReasonString.integration.test.d.ts.map

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

package/dist/userRepository/api/flagUser.d.ts

@@ -1,22 +1,63 @@
+declare type FlagUser = {
+    /**
+     * ```js
+     * import { UserRepository } from '@amityco/ts-sdk'
+     * const flagged = await UserRepository.flagUser('userId')
+     * ```
+     *
+     * Flags a user with a typeless report. No request body is sent.
+     *
+     * To report a specific profile field use `flagUserProfile(userId, { field, comment })`;
+     * to report behavior use `flagUserBehavior(userId, { reason, comment })`.
+     *
+     * @param userId The ID of the user to be flagged
+     * @returns the flagged {@link Amity.User}
+     */
+    (userId: Amity.User['userId'], options?: undefined): Promise<Amity.User>;
+    /**
+     * ```js
+     * import { UserRepository } from '@amityco/ts-sdk'
+     * const flaggedBehavior = await UserRepository.flagUser('userId', {
+     *   reportType: 'behavior',
+     *   reason: 'Harassment or bullying',
+     *   comment: 'optional free-text',
+     * })
+     * ```
+     *
+     * @deprecated Use `flagUserProfile(userId, { field, comment })` to report a profile
+     * field, or `flagUserBehavior(userId, { reason, comment })` to report behavior. For a
+     * custom `Others` reason, pass `reason: ContentFlagReasonEnum.Others` and put the text
+     * in `comment`. `flagUser(userId)` without options stays supported. This overload's
+     * request mapping is unchanged and stays available throughout the current major version.
+     *
+     * @param userId The ID of the user to be flagged
+     * @param options Optional report metadata forwarded to the server as the request
+     *   body: `reportType`, `reason`, `comment`. Only non-undefined fields are included.
+     *   All validation is server-side; a bodyless call produces a typeless report.
+     * @returns the flagged {@link Amity.User}
+     */
+    (userId: Amity.User['userId'], options?: Amity.UserReportOptions): Promise<Amity.User>;
+};
 /**
  * ```js
  * import { UserRepository } from '@amityco/ts-sdk'
+ *
+ * // Typeless report (supported).
  * const flagged = await UserRepository.flagUser('userId')
- * const flaggedBehavior = await UserRepository.flagUser('userId', {
- *   reportType: 'behavior',
- *   reason: 'Harassment or bullying',
- *   comment: 'optional free-text',
- * })
  * ```
  *
+ * Flags a user. Two call shapes are accepted (see the overloads): id-only, which
+ * sends no body and stays supported, and the deprecated structured options object,
+ * whose request mapping is unchanged. New code reporting a profile field or behavior
+ * should use `flagUserProfile` or `flagUserBehavior`.
+ *
  * @param userId The ID of the user to be flagged
- * @param options Optional report metadata forwarded to the server as the request
- *   body: `reportType`, `reason`, `comment`. Only non-null fields are included.
- *   All validation is server-side; a bodyless call produces a typeless report.
+ * @param options Deprecated report metadata; omit for a typeless report
  * @returns the flagged {@link Amity.User}
  *
  * @category User API
  * @async
  * */
-export declare const flagUser: (userId: Amity.User['userId'], options?: Amity.UserReportOptions) => Promise<Amity.User>;
+export declare const flagUser: FlagUser;
+export {};
 //# sourceMappingURL=flagUser.d.ts.map

package/dist/userRepository/api/flagUser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flagUser.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/flagUser.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;KAmBK;AACL,eAAO,MAAM,QAAQ,WACX,MAAM,IAAI,CAAC,QAAQ,CAAC,YAClB,MAAM,iBAAiB,KAChC,QAAQ,MAAM,IAAI,CAoBpB,CAAC"}
+{"version":3,"file":"flagUser.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/flagUser.ts"],"names":[],"mappings":"AAiBA,aAAK,QAAQ,GAAG;IACd;;;;;;;;;;;;;OAaG;IACH,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACzE;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,EAAE,KAAK,CAAC,iBAAiB,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;CACxF,CAAC;AAKF;;;;;;;;;;;;;;;;;;;KAmBK;AACL,eAAO,MAAM,QAAQ,EAAE,QAuBtB,CAAC"}

package/dist/userRepository/api/flagUserBehavior.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ```js
+ * import { UserRepository, ContentFlagReasonEnum } from '@amityco/ts-sdk'
+ * const flagged = await UserRepository.flagUserBehavior('userId', {
+ *   reason: ContentFlagReasonEnum.Others,
+ *   comment: 'Impersonating our brand',
+ * })
+ * ```
+ *
+ * Reports a user's behavior. `reason` is required and is one of the nine
+ * `ContentFlagReasonEnum` values, sent as its canonical label. Reporter text, including
+ * the explanation for `Others`, always travels in `comment`; the reason never carries text.
+ *
+ * `comment` is trimmed; a blank comment is omitted from the request; a comment longer
+ * than 300 characters after trimming is rejected before any request. Otherwise the
+ * trimmed text is sent unchanged.
+ *
+ * Sends `POST /api/v4/me/flags/:userId` with `{ reportType: 'behavior', reason, comment? }`.
+ *
+ * @param userId The ID of the user to be reported
+ * @param options `reason` is a `ContentFlagReasonEnum` value; `comment` is optional free text
+ * @returns the flagged {@link Amity.User}
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when `options` is missing or malformed, `reason` is missing or unknown, or `comment` is over 300 characters, before any request is made
+ *
+ * @category User API
+ * @async
+ * */
+export declare const flagUserBehavior: (userId: Amity.User['userId'], options: Amity.UserBehaviorReportOptions) => Promise<Amity.User>;
+//# sourceMappingURL=flagUserBehavior.d.ts.map

package/dist/userRepository/api/flagUserBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagUserBehavior.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/flagUserBehavior.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;KA0BK;AACL,eAAO,MAAM,gBAAgB,WACnB,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,yBAAyB,KACvC,QAAQ,MAAM,IAAI,CAC4D,CAAC"}

package/dist/userRepository/api/flagUserProfile.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ```js
+ * import { UserRepository, UserProfileFieldEnum } from '@amityco/ts-sdk'
+ * const flagged = await UserRepository.flagUserProfile('userId', {
+ *   field: UserProfileFieldEnum.AVATAR,
+ *   comment: 'Nudity in profile photo',
+ * })
+ * ```
+ *
+ * Reports one of a user's profile fields (display name, description or avatar). The
+ * call has no reason: profile reports never carry one, so the backend's reason rules
+ * cannot be violated from here. A `reason` key passed at runtime is ignored and never sent.
+ *
+ * `comment` is trimmed; a blank comment is omitted from the request; a comment longer
+ * than 300 characters after trimming is rejected before any request. Otherwise the
+ * trimmed text is sent unchanged.
+ *
+ * Sends `POST /api/v4/me/flags/:userId` with `{ reportType: <field>, comment? }`.
+ *
+ * @param userId The ID of the user to be reported
+ * @param options `field` is a `UserProfileFieldEnum` value; `comment` is optional free text
+ * @returns the flagged {@link Amity.User}
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when `options` is missing or malformed, or `comment` is over 300 characters, before any request is made
+ *
+ * @category User API
+ * @async
+ * */
+export declare const flagUserProfile: (userId: Amity.User['userId'], options: Amity.UserProfileReportOptions) => Promise<Amity.User>;
+//# sourceMappingURL=flagUserProfile.d.ts.map

package/dist/userRepository/api/flagUserProfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagUserProfile.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/flagUserProfile.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;KA0BK;AACL,eAAO,MAAM,eAAe,WAClB,MAAM,IAAI,CAAC,QAAQ,CAAC,WACnB,MAAM,wBAAwB,KACtC,QAAQ,MAAM,IAAI,CAC0D,CAAC"}

package/dist/userRepository/api/index.d.ts

@@ -1,6 +1,8 @@
 export { getUserByIds } from './getUserByIds';
 export { updateUser } from './updateUser';
 export { flagUser } from './flagUser';
+export { flagUserProfile } from './flagUserProfile';
+export { flagUserBehavior } from './flagUserBehavior';
 export { unflagUser } from './unflagUser';
 export { isUserFlaggedByMe } from './isUserFlaggedByMe';
 export { getAllBlockedUsers } from './getAllBlockedUsers';

package/dist/userRepository/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/userRepository/api/tests/integration/flagUser.overloads.integration.test.d.ts

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

package/dist/userRepository/api/tests/integration/flagUser.overloads.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagUser.overloads.integration.test.d.ts","sourceRoot":"","sources":["../../../../../src/userRepository/api/tests/integration/flagUser.overloads.integration.test.ts"],"names":[],"mappings":""}

package/dist/userRepository/api/tests/integration/flagUserBehavior.integration.test.d.ts

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

package/dist/userRepository/api/tests/integration/flagUserBehavior.integration.test.d.ts.map

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

package/dist/userRepository/api/tests/integration/flagUserProfile.integration.test.d.ts

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

package/dist/userRepository/api/tests/integration/flagUserProfile.integration.test.d.ts.map

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

package/dist/userRepository/utils/submitUserReport.d.ts

@@ -0,0 +1,10 @@
+import type { UserReportBody } from './userReport';
+/**
+ * Sends a validated split user report (`flagUserProfile` / `flagUserBehavior`) to the
+ * same endpoint as `flagUser`, then persists the returned user and fires `user.flagged`
+ * exactly as `flagUser` does, so all three calls share return, cache and event behaviour.
+ *
+ * Not exported from the public API.
+ */
+export declare const submitUserReport: (apiName: 'flagUserProfile' | 'flagUserBehavior', userId: Amity.User['userId'], body: UserReportBody) => Promise<Amity.User>;
+//# sourceMappingURL=submitUserReport.d.ts.map

package/dist/userRepository/utils/submitUserReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submitUserReport.d.ts","sourceRoot":"","sources":["../../../src/userRepository/utils/submitUserReport.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,YAClB,iBAAiB,GAAG,kBAAkB,UACvC,MAAM,IAAI,CAAC,QAAQ,CAAC,QACtB,cAAc,KACnB,QAAQ,MAAM,IAAI,CAkBpB,CAAC"}

package/dist/userRepository/utils/userReport.d.ts

@@ -0,0 +1,35 @@
+import { UserProfileFieldEnum } from '~/@types';
+/** Maximum `comment` length, in string length units, after trimming. */
+export declare const USER_REPORT_COMMENT_MAX_LENGTH = 300;
+/** Request body sent to `POST /api/v4/me/flags/:userId` by the split user-report calls. */
+export declare type UserReportBody = {
+    reportType: `${UserProfileFieldEnum}` | 'behavior';
+    reason?: string;
+    comment?: string;
+};
+/**
+ * Normalizes an optional reporter `comment`: it must be a string when supplied (`null`
+ * is not a valid supplied comment); it is trimmed; a blank result is omitted (the
+ * backend rejects `""`); a result longer than 300 characters is rejected before any
+ * request. Otherwise the trimmed text is returned unchanged.
+ *
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` for a non-string or over-length comment
+ */
+export declare const normalizeUserReportComment: (apiName: string, comment: unknown) => string | undefined;
+/**
+ * Validates `flagUserProfile` options and builds its request body. Untyped callers can
+ * pass anything at runtime, so nothing is trusted from the declared type. Any `reason`
+ * key is ignored and never sent.
+ *
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when the options are malformed
+ */
+export declare const toUserProfileReportBody: (options: unknown) => UserReportBody;
+/**
+ * Validates `flagUserBehavior` options and builds its request body. `reason` must be one
+ * of the nine `ContentFlagReasonEnum` values and is sent as that canonical label;
+ * `reportType` is always `behavior`.
+ *
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when the options are malformed
+ */
+export declare const toUserBehaviorReportBody: (options: unknown) => UserReportBody;
+//# sourceMappingURL=userReport.d.ts.map

package/dist/userRepository/utils/userReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userReport.d.ts","sourceRoot":"","sources":["../../../src/userRepository/utils/userReport.ts"],"names":[],"mappings":"AACA,OAAO,EAAyB,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEvE,wEAAwE;AACxE,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAElD,2FAA2F;AAC3F,oBAAY,cAAc,GAAG;IAC3B,UAAU,EAAE,GAAG,oBAAoB,EAAE,GAAG,UAAU,CAAC;IACnD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAiBF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,YAC5B,MAAM,WACN,OAAO,KACf,MAAM,GAAG,SAkBX,CAAC;AAKF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,YAAa,OAAO,KAAG,cAc1D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,YAAa,OAAO,KAAG,cAc3D,CAAC"}

package/dist/utils/contentFlag.d.ts

@@ -0,0 +1,28 @@
+/** Request body shared by the post, comment and message flag endpoints. */
+export declare type ContentFlagBody = {
+    reason: string;
+    detail?: string;
+};
+/**
+ * True when a public `flagX(id, input)` argument is the legacy shape (a reason string
+ * or nothing). Anything else is routed to the `Amity.ContentFlagOptions` path, whose
+ * validation rejects malformed values before any request is made.
+ */
+export declare const isLegacyContentFlagReason: (input: unknown) => input is Amity.ContentFlagReason | undefined;
+/**
+ * Validates an `Amity.ContentFlagOptions` argument. Untyped (plain JS) callers can pass
+ * anything at runtime, so the checks do not trust the declared type: the value must be a
+ * plain object, `reason` must be one of the nine `ContentFlagReasonEnum` values and
+ * `detail`, when supplied, must be a string (`null` is not a valid supplied detail).
+ *
+ * @param apiName used in the error message, e.g. `flagPost`
+ * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when the options are malformed
+ */
+export declare const validateContentFlagOptions: (apiName: string, options: unknown) => Amity.ContentFlagOptions;
+/**
+ * Builds the request body for validated options. `detail` is forwarded unchanged (empty
+ * and whitespace-only strings included) and omitted from the body when `undefined`; the
+ * backend enforces the 300-character limit.
+ */
+export declare const toContentFlagBody: ({ reason, detail }: Amity.ContentFlagOptions) => ContentFlagBody;
+//# sourceMappingURL=contentFlag.d.ts.map

package/dist/utils/contentFlag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentFlag.d.ts","sourceRoot":"","sources":["../../src/utils/contentFlag.ts"],"names":[],"mappings":"AAGA,2EAA2E;AAC3E,oBAAY,eAAe,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAIlE;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,UAC7B,OAAO,iDACmF,CAAC;AAEpG;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,YAC5B,MAAM,WACN,OAAO,KACf,MAAM,kBAoBR,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,uBAAwB,MAAM,kBAAkB,KAAG,eACzB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "7.29.0",
+  "version": "7.29.1-cc0fba8.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",