@wildix/stream-client 0.0.15 → 4.0.1

package/dist-es/endpoint/bdd.js

@@ -0,0 +1,25 @@
+import { BinaryDecisionDiagram } from "@smithy/core/endpoints";
+const a = "stringEquals", b = { "ref": "endpoint" }, c = { "ref": "env" };
+const _data = {
+    conditions: [
+        ["isSet", [b]],
+        [a, [c, "stable"]],
+        [a, [c, "stage"]]
+    ],
+    results: [
+        [-1],
+        [b, {}],
+        ["https://{serviceRegion}.stream-stable.wildix.com", {}],
+        ["https://{serviceRegion}.stream-stage.wildix.com", {}],
+        ["https://{serviceRegion}.stream.wildix.com", {}]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, r + 1, 3,
+    1, r + 2, 4,
+    2, r + 3, r + 4,
+]);
+export const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);

package/dist-es/endpoint/endpointResolver.js

@@ -0,0 +1,12 @@
+import { decideEndpoint, EndpointCache } from "@smithy/core/endpoints";
+import { bdd } from "./bdd";
+const cache = new EndpointCache({
+    size: 50,
+    params: ["endpoint", "env", "serviceRegion"],
+});
+export const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};

package/dist-es/index.js

@@ -1,5 +1,8 @@
 export * from "./StreamServiceClient";
 export * from "./StreamService";
 export * from "./commands";
-export * from "./models";
+export * from "./schemas/schemas_0";
+export * from "./models/enums";
+export * from "./models/errors";
+export * from "./models/models_0";
 export { StreamServiceServiceException } from "./models/StreamServiceServiceException";

package/dist-es/models/StreamServiceServiceException.js

@@ -1,4 +1,4 @@
-import { ServiceException as __ServiceException, } from "@smithy/smithy-client";
+import { ServiceException as __ServiceException, } from "@smithy/core/client";
 export { __ServiceException };
 export class StreamServiceServiceException extends __ServiceException {
     constructor(options) {

package/dist-es/models/enums.js

@@ -0,0 +1,111 @@
+export const ButtonVariant = {
+    CONTAINED: "contained",
+    OUTLINED: "outlined",
+};
+export const ChannelMemberRole = {
+    MEMBER: "member",
+    SUPERVISOR: "supervisor",
+};
+export const AssignChannelVariant = {
+    ADAPTIVE: "ADAPTIVE",
+    EVERYBODY: "EVERYBODY",
+    SELECTED: "SELECTED",
+    SKIP: "SKIP",
+};
+export const ChannelAccess = {
+    PRIVATE: "private",
+    PUBLIC: "public",
+};
+export const ChannelType = {
+    DIRECT: "direct",
+    GROUP: "group",
+};
+export const ChannelContextEventAttendeeStatus = {
+    ACCEPTED: "accepted",
+    DECLINED: "declined",
+    NONE: "none",
+    TENTATIVE: "tentative",
+};
+export const ChannelContextSource = {
+    KITE: "kite",
+};
+export const MessageType = {
+    DELETED: "deleted",
+    REGULAR: "regular",
+    SYSTEM: "system",
+};
+export const ChannelWhatsAppStatus = {
+    CHANNEL_CLOSED: "24h_channel_closed",
+};
+export const ChannelsFilter = {
+    ARCHIVED: "archived",
+    UNREAD: "unread",
+};
+export const GroupChannelCreationEventType = {
+    CONVERSATION_CREATED: "conversation_created",
+    CONVERSATION_CREATED_WITH_NAME: "conversation_created_with_name",
+};
+export const MessageSmsStatus = {
+    DELIVERED: "delivered",
+    ERROR: "error",
+    SENT: "sent",
+    TRYING: "trying",
+};
+export const MessageWhatsAppStatus = {
+    DELIVERED: "delivered",
+    ERROR: "error",
+    SENT: "sent",
+    TRYING: "trying",
+};
+export const TargetNotEligibleReason = {
+    NO_LICENSE: "no_license",
+};
+export const SectionType = {
+    CUSTOM: "custom",
+    SYSTEM: "system",
+};
+export var DownloadStrategy;
+(function (DownloadStrategy) {
+    DownloadStrategy[DownloadStrategy["DEFAULT"] = 0] = "DEFAULT";
+    DownloadStrategy[DownloadStrategy["DOWNLOAD"] = 1] = "DOWNLOAD";
+})(DownloadStrategy || (DownloadStrategy = {}));
+export const FileCategory = {
+    GENERAL: "channels",
+    RECORDING: "recordings",
+    WIZY_RECORDING: "wizyconfRecordings",
+};
+export const GroupChannelUnsetOptions = {
+    ACCESS: "access",
+    ASSIGNEE: "assignee",
+    BROADCAST: "broadcast",
+    CONTEXT: "context",
+    CONTEXT_EVENTS: "contextEvents",
+    CONTEXT_PTT: "contextPtt",
+    DESCRIPTION: "description",
+    KITE_ASSIGN: "kiteAssign",
+    MMS: "mms",
+    PICTURE: "picture",
+    PICTURE_COLOR: "pictureColor",
+    SERVICE: "service",
+    SERVICE_TITLE: "serviceTitle",
+    SMS: "sms",
+    SUBJECT: "subject",
+    WHATSAPP: "whatsapp",
+    WHATSAPP_STATUS: "whatsappStatus",
+};
+export const MentionsFilter = {
+    UNREAD: "unread",
+};
+export const MessageUnsetFields = {
+    ATTACHMENTS: "attachments",
+    ELEMENTS: "elements",
+    FORWARD: "forward",
+    MARKDOWN: "markdown",
+    MENTIONS: "mentions",
+    QUOTE: "quote",
+    SMS: "sms",
+    SMS_STATUS: "smsStatus",
+    TEXT: "text",
+    WHATSAPP: "whatsapp",
+    WHATSAPP_STATUS: "whatsappStatus",
+};

package/dist-es/models/errors.js

@@ -0,0 +1,191 @@
+import { StreamServiceServiceException as __BaseException } from "./StreamServiceServiceException";
+export class ForbiddenException extends __BaseException {
+    name = "ForbiddenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ForbiddenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ForbiddenException.prototype);
+    }
+}
+export class RateLimitExceededException extends __BaseException {
+    name = "RateLimitExceededException";
+    $fault = "client";
+    rateLimit;
+    rateLimitRemaining;
+    rateLimitReset;
+    retryAfter;
+    constructor(opts) {
+        super({
+            name: "RateLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RateLimitExceededException.prototype);
+        this.rateLimit = opts.rateLimit;
+        this.rateLimitRemaining = opts.rateLimitRemaining;
+        this.rateLimitReset = opts.rateLimitReset;
+        this.retryAfter = opts.retryAfter;
+    }
+}
+export class UnauthorizedException extends __BaseException {
+    name = "UnauthorizedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnauthorizedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnauthorizedException.prototype);
+    }
+}
+export class ValidationException extends __BaseException {
+    name = "ValidationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ValidationException.prototype);
+    }
+}
+export class ChannelNotFoundException extends __BaseException {
+    name = "ChannelNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ChannelNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ChannelNotFoundException.prototype);
+    }
+}
+export class MemberAlreadyExistException extends __BaseException {
+    name = "MemberAlreadyExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MemberAlreadyExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MemberAlreadyExistException.prototype);
+    }
+}
+export class StreamServiceException extends __BaseException {
+    name = "StreamServiceException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "StreamServiceException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StreamServiceException.prototype);
+    }
+}
+export class ChannelAlreadyExistException extends __BaseException {
+    name = "ChannelAlreadyExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ChannelAlreadyExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ChannelAlreadyExistException.prototype);
+    }
+}
+export class TargetNotEligibleException extends __BaseException {
+    name = "TargetNotEligibleException";
+    $fault = "client";
+    reason;
+    constructor(opts) {
+        super({
+            name: "TargetNotEligibleException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TargetNotEligibleException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export class TargetNotFoundException extends __BaseException {
+    name = "TargetNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TargetNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TargetNotFoundException.prototype);
+    }
+}
+export class MemberNotFoundException extends __BaseException {
+    name = "MemberNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MemberNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MemberNotFoundException.prototype);
+    }
+}
+export class MessageNotFoundException extends __BaseException {
+    name = "MessageNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MessageNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MessageNotFoundException.prototype);
+    }
+}
+export class SectionNotFoundException extends __BaseException {
+    name = "SectionNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SectionNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SectionNotFoundException.prototype);
+    }
+}
+export class FileNotFoundException extends __BaseException {
+    name = "FileNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FileNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FileNotFoundException.prototype);
+    }
+}
+export class MarkUnreadChannelsLimitReachedException extends __BaseException {
+    name = "MarkUnreadChannelsLimitReachedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MarkUnreadChannelsLimitReachedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MarkUnreadChannelsLimitReachedException.prototype);
+    }
+}