@openclaw/discord 2026.7.2-beta.1 → 2026.7.2-beta.3

package/node_modules/@discord/embedded-app-sdk/output/schema/responses.mjs

@@ -0,0 +1,163 @@
+import { object as objectType, string as stringType, array as arrayType, number as numberType, boolean as booleanType, bigint as bigIntType, null as nullType, optional as optionalType, nativeEnum as nativeEnumType } from '../lib/zod/lib/index.mjs';
+import { GuildMember, UserVoiceState, Message, Channel, VoiceSettingsIO, VoiceSettingsMode, ShortcutKey, Sku, Entitlement, ReceiveFramePayload, Commands, ChannelTypesObject, Activity } from './common.mjs';
+import { zodCoerceUnhandledValue, fallbackToDefault } from '../utils/zodUtils.mjs';
+import { Schemas } from '../generated/schemas.mjs';
+export { AuthenticateResponseSchema as AuthenticateResponse, InitiateImageUploadResponseSchema as InitiateImageUploadResponse } from '../generated/schemas.mjs';
+import assertUnreachable from '../utils/assertUnreachable.mjs';
+
+const EmptyResponse = objectType({}).nullable();
+const AuthorizeResponse = objectType({
+    code: stringType(),
+});
+const GetGuildsResponse = objectType({
+    guilds: arrayType(objectType({
+        id: stringType(),
+        name: stringType(),
+    })),
+});
+const GetGuildResponse = objectType({
+    id: stringType(),
+    name: stringType(),
+    icon_url: stringType().optional(),
+    members: arrayType(GuildMember),
+});
+const GetChannelResponse = objectType({
+    id: stringType(),
+    type: zodCoerceUnhandledValue(ChannelTypesObject),
+    guild_id: stringType().optional().nullable(),
+    name: stringType().optional().nullable(),
+    topic: stringType().optional().nullable(),
+    bitrate: numberType().optional().nullable(),
+    user_limit: numberType().optional().nullable(),
+    position: numberType().optional().nullable(),
+    voice_states: arrayType(UserVoiceState),
+    messages: arrayType(Message),
+});
+const GetChannelsResponse = objectType({
+    channels: arrayType(Channel),
+});
+const NullableChannelResponse = GetChannelResponse.nullable();
+const SelectVoiceChannelResponse = GetChannelResponse.nullable();
+const SelectTextChannelResponse = GetChannelResponse.nullable();
+const VoiceSettingsResponse = objectType({
+    input: VoiceSettingsIO,
+    output: VoiceSettingsIO,
+    mode: VoiceSettingsMode,
+    automatic_gain_control: booleanType(),
+    echo_cancellation: booleanType(),
+    noise_suppression: booleanType(),
+    qos: booleanType(),
+    silence_warning: booleanType(),
+    deaf: booleanType(),
+    mute: booleanType(),
+});
+const SubscribeResponse = objectType({
+    evt: stringType(),
+});
+const CaptureShortcutResponse = objectType({ shortcut: ShortcutKey });
+const SetActivityResponse = Activity;
+const GetSkusResponse = objectType({ skus: arrayType(Sku) });
+const GetEntitlementsResponse = objectType({ entitlements: arrayType(Entitlement) });
+const StartPurchaseResponse = arrayType(Entitlement).nullable();
+const SetConfigResponse = objectType({
+    use_interactive_pip: booleanType(),
+});
+const UserSettingsGetLocaleResponse = objectType({
+    locale: stringType(),
+});
+const EncourageHardwareAccelerationResponse = objectType({
+    enabled: booleanType(),
+});
+const GetChannelPermissionsResponse = objectType({
+    permissions: bigIntType().or(stringType()),
+});
+const OpenExternalLinkResponse = fallbackToDefault(objectType({ opened: booleanType().or(nullType()) }).default({ opened: null }));
+/**
+ * Because of the nature of Platform Behavior changes
+ * every key/value is optional and may eventually be removed
+ */
+const GetPlatformBehaviorsResponse = objectType({
+    iosKeyboardResizesView: optionalType(booleanType()),
+});
+const ResponseFrame = ReceiveFramePayload.extend({
+    cmd: nativeEnumType(Commands),
+    evt: nullType(),
+});
+function parseResponseData({ cmd, data }) {
+    switch (cmd) {
+        case Commands.AUTHORIZE:
+            return AuthorizeResponse.parse(data);
+        case Commands.CAPTURE_SHORTCUT:
+            return CaptureShortcutResponse.parse(data);
+        case Commands.ENCOURAGE_HW_ACCELERATION:
+            return EncourageHardwareAccelerationResponse.parse(data);
+        case Commands.GET_CHANNEL:
+            return GetChannelResponse.parse(data);
+        case Commands.GET_CHANNELS:
+            return GetChannelsResponse.parse(data);
+        case Commands.GET_CHANNEL_PERMISSIONS:
+            return GetChannelPermissionsResponse.parse(data);
+        case Commands.GET_GUILD:
+            return GetGuildResponse.parse(data);
+        case Commands.GET_GUILDS:
+            return GetGuildsResponse.parse(data);
+        case Commands.GET_PLATFORM_BEHAVIORS:
+            return GetPlatformBehaviorsResponse.parse(data);
+        case Commands.GET_CHANNEL:
+            return GetChannelResponse.parse(data);
+        case Commands.SELECT_TEXT_CHANNEL:
+            return SelectTextChannelResponse.parse(data);
+        case Commands.SELECT_VOICE_CHANNEL:
+            return SelectVoiceChannelResponse.parse(data);
+        case Commands.SET_ACTIVITY:
+            return SetActivityResponse.parse(data);
+        case Commands.GET_SKUS_EMBEDDED:
+            return GetSkusResponse.parse(data);
+        case Commands.GET_ENTITLEMENTS_EMBEDDED:
+            return GetEntitlementsResponse.parse(data);
+        case Commands.SET_CONFIG:
+            return SetConfigResponse.parse(data);
+        case Commands.START_PURCHASE:
+            return StartPurchaseResponse.parse(data);
+        case Commands.SUBSCRIBE:
+        case Commands.UNSUBSCRIBE:
+            return SubscribeResponse.parse(data);
+        case Commands.USER_SETTINGS_GET_LOCALE:
+            return UserSettingsGetLocaleResponse.parse(data);
+        case Commands.OPEN_EXTERNAL_LINK:
+            return OpenExternalLinkResponse.parse(data);
+        // Empty Responses
+        case Commands.SET_ORIENTATION_LOCK_STATE:
+        case Commands.SET_CERTIFIED_DEVICES:
+        case Commands.SEND_ANALYTICS_EVENT:
+        case Commands.OPEN_INVITE_DIALOG:
+        case Commands.CAPTURE_LOG:
+        case Commands.GET_SKUS:
+        case Commands.GET_ENTITLEMENTS:
+            return EmptyResponse.parse(data);
+        // START-GENERATED-SECTION
+        case Commands.AUTHENTICATE:
+        case Commands.GET_ACTIVITY_INSTANCE_CONNECTED_PARTICIPANTS:
+        case Commands.GET_QUEST:
+        case Commands.GET_QUEST_ENROLLMENT_STATUS:
+        case Commands.GET_RELATIONSHIPS:
+        case Commands.GET_USER:
+        case Commands.INITIATE_IMAGE_UPLOAD:
+        case Commands.INVITE_USER_EMBEDDED:
+        case Commands.OPEN_SHARE_MOMENT_DIALOG:
+        case Commands.QUEST_START_TIMER:
+        case Commands.REQUEST_PROXY_TICKET_REFRESH:
+        case Commands.SHARE_INTERACTION:
+        case Commands.SHARE_LINK:
+            // END-GENERATED-SECTION
+            const { response } = Schemas[cmd];
+            return response.parse(data);
+        default:
+            assertUnreachable(cmd, new Error(`Unrecognized command ${cmd}`));
+    }
+}
+function parseResponsePayload(payload) {
+    return Object.assign(Object.assign({}, payload), { data: parseResponseData(payload) });
+}
+
+export { AuthorizeResponse, CaptureShortcutResponse, EmptyResponse, EncourageHardwareAccelerationResponse, GetChannelPermissionsResponse, GetChannelResponse, GetChannelsResponse, GetEntitlementsResponse, GetGuildResponse, GetGuildsResponse, GetPlatformBehaviorsResponse, GetSkusResponse, NullableChannelResponse, OpenExternalLinkResponse, ResponseFrame, SelectTextChannelResponse, SelectVoiceChannelResponse, SetActivityResponse, SetConfigResponse, StartPurchaseResponse, SubscribeResponse, UserSettingsGetLocaleResponse, VoiceSettingsResponse, parseResponsePayload };

package/node_modules/@discord/embedded-app-sdk/output/schema/types.d.ts

@@ -0,0 +1,61 @@
+import * as zod from 'zod';
+import * as Events from './events';
+import * as Common from './common';
+import type { GetActivityInstanceConnectedParticipantsResponse } from '../generated/schemas';
+export type TSendCommandPayload<C extends Common.Commands = Common.Commands, I extends any = any> = {
+    cmd: Exclude<C, Common.Commands.SUBSCRIBE | Common.Commands.UNSUBSCRIBE>;
+    args?: I;
+    transfer?: Transferable[];
+} | {
+    cmd: Common.Commands.SUBSCRIBE | Common.Commands.UNSUBSCRIBE;
+    args?: I;
+    evt: string;
+};
+export type TSendCommand<C extends Common.Commands = Common.Commands, I extends any = any, O extends any = any> = ({ cmd, args, }: TSendCommandPayload<C, I>) => Promise<O>;
+export type User = zod.infer<typeof Common.User>;
+export type GuildMember = zod.infer<typeof Common.GuildMember>;
+export type Emoji = zod.infer<typeof Common.Emoji>;
+export type VoiceState = zod.infer<typeof Common.VoiceState>;
+export type Status = zod.infer<typeof Common.Status>;
+export type Activity = zod.infer<typeof Common.Activity>;
+export type PermissionOverwrite = zod.infer<typeof Common.PermissionOverwrite>;
+export type ChannelTypes = typeof Common.ChannelTypesObject;
+export type Channel = zod.infer<typeof Common.Channel>;
+export type PresenceUpdate = zod.infer<typeof Common.PresenceUpdate>;
+export type Role = zod.infer<typeof Common.Role>;
+export type Guild = zod.infer<typeof Common.Guild>;
+export type ChannelMention = zod.infer<typeof Common.ChannelMention>;
+export type Attachment = zod.infer<typeof Common.Attachment>;
+export type EmbedFooter = zod.infer<typeof Common.EmbedFooter>;
+export type Image = zod.infer<typeof Common.Image>;
+export type Video = zod.infer<typeof Common.Video>;
+export type EmbedProvider = zod.infer<typeof Common.EmbedProvider>;
+export type EmbedField = zod.infer<typeof Common.EmbedField>;
+export type Embed = zod.infer<typeof Common.Embed>;
+export type Reaction = zod.infer<typeof Common.Reaction>;
+export type MessageActivity = zod.infer<typeof Common.MessageActivity>;
+export type MessageReference = zod.infer<typeof Common.MessageReference>;
+export type Message = zod.infer<typeof Common.Message>;
+export type VoiceDevice = zod.infer<typeof Common.VoiceDevice>;
+export type KeyTypes = typeof Common.KeyTypesObject;
+export type ShortcutKey = zod.infer<typeof Common.ShortcutKey>;
+export type VoiceSettingsMode = zod.infer<typeof Common.VoiceSettingsMode>;
+export type VoiceSettingsIO = zod.infer<typeof Common.VoiceSettingsIO>;
+export type CertifiedDevice = zod.infer<typeof Common.CertifiedDevice>;
+export type ScopesObject = typeof Common.ScopesObject;
+export type StatusObject = typeof Common.StatusObject;
+export type PermissionOverwriteTypeEnum = typeof Common.PermissionOverwriteTypeObject;
+export type ChannelTypesObject = typeof Common.ChannelTypesObject;
+export type KeyTypesObject = typeof Common.KeyTypesObject;
+export type VoiceSettingModeTypeObject = typeof Common.VoiceSettingModeTypeObject;
+export type CertifiedDeviceTypeObject = typeof Common.CertifiedDeviceTypeObject;
+export type SkuTypeObject = typeof Common.SkuTypeObject;
+export type EntitlementTypesObject = typeof Common.EntitlementTypesObject;
+export type VoiceConnectionStatusStateObject = typeof Events.VoiceConnectionStatusStateObject;
+export type ActivityJoinIntentObject = typeof Events.ActivityJoinIntentObject;
+export type OrientationLockStateTypeObject = typeof Common.OrientationLockStateTypeObject;
+export type ThermalStateTypeObject = typeof Common.ThermalStateTypeObject;
+export type OrientationTypeObject = typeof Common.OrientationTypeObject;
+export type LayoutModeTypeObject = typeof Common.LayoutModeTypeObject;
+export type OAuthScopes = 'bot' | 'rpc' | 'identify' | 'connections' | 'email' | 'guilds' | 'guilds.join' | 'guilds.members.read' | 'gdm.join' | 'messages.read' | 'rpc.notifications.read' | 'rpc.voice.write' | 'rpc.voice.read' | 'rpc.activities.write' | 'webhook.incoming' | 'applications.commands' | 'applications.builds.upload' | 'applications.builds.read' | 'applications.store.update' | 'applications.entitlements' | 'relationships.read' | 'activities.read' | 'activities.write' | 'dm_channels.read';
+export type { GetActivityInstanceConnectedParticipantsResponse };

package/node_modules/@discord/embedded-app-sdk/output/utils/BigFlagUtils.cjs

@@ -0,0 +1,235 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var BigInteger = require('../_virtual/BigInteger.cjs');
+
+/**
+ * Context: Due to Discord supporting more than 32 permissions, permission calculation has become more complicated than naive
+ * bit operations on `number`s. To support this generically, we have created BigFlagUtils to work with bit-flags greater
+ * than 32-bits in size.
+ *
+ * Ideally, we would like to use BigInt, which is pretty efficient, but some JavaScript engines do not support it.
+ *
+ * This file is intended to be a set of lower-level operators that act directly on "BigFlags".
+ *
+ * If you're working with permissions, in most cases you can probably use PermissionUtils.
+ */
+const MAX_BIG_INT = 64;
+const SMALL_INT = 16;
+const PARTS = MAX_BIG_INT / SMALL_INT;
+function checkBrowserSupportsBigInt() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        BigInt;
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Takes the sliced output of `toHexReverseArray` and converts hex to decimal.
+ */
+function fromHexReverseArray(hexValues, start, size) {
+    let value = 0;
+    for (let i = 0; i < size; i++) {
+        const byte = hexValues[start + i];
+        if (byte === undefined) {
+            break;
+        }
+        value += byte * 16 ** i;
+    }
+    return value;
+}
+/**
+ * Converts a number string to array of hex bytes based on the implementation found at
+ * https://stackoverflow.com/questions/18626844/convert-a-large-integer-to-a-hex-string-in-javascript
+ *
+ * To avoid extra allocations it returns the values in reverse.
+ */
+function toHexReverseArray(value) {
+    const sum = [];
+    for (let i = 0; i < value.length; i++) {
+        let s = Number(value[i]);
+        for (let j = 0; s || j < sum.length; j++) {
+            s += (sum[j] || 0) * 10;
+            sum[j] = s % 16;
+            s = (s - sum[j]) / 16;
+        }
+    }
+    return sum;
+}
+/**
+ * Splits a big integers into array of small integers to perform fast bitwise operations.
+ */
+function splitBigInt(value) {
+    const sum = toHexReverseArray(value);
+    const parts = Array(PARTS);
+    for (let i = 0; i < PARTS; i++) {
+        // Highest bits to lowest bits.
+        parts[PARTS - 1 - i] = fromHexReverseArray(sum, i * PARTS, PARTS);
+    }
+    return parts;
+}
+class HighLow {
+    static fromString(value) {
+        return new HighLow(splitBigInt(value), value);
+    }
+    static fromBit(index) {
+        const parts = Array(PARTS);
+        const offset = Math.floor(index / SMALL_INT);
+        for (let i = 0; i < PARTS; i++) {
+            // Highest bits to lowest bits.
+            parts[PARTS - 1 - i] = i === offset ? 1 << (index - offset * SMALL_INT) : 0;
+        }
+        return new HighLow(parts);
+    }
+    constructor(parts, str) {
+        this.parts = parts;
+        this.str = str;
+    }
+    and({ parts }) {
+        return new HighLow(this.parts.map((v, i) => v & parts[i]));
+    }
+    or({ parts }) {
+        return new HighLow(this.parts.map((v, i) => v | parts[i]));
+    }
+    xor({ parts }) {
+        return new HighLow(this.parts.map((v, i) => v ^ parts[i]));
+    }
+    not() {
+        return new HighLow(this.parts.map((v) => ~v));
+    }
+    equals({ parts }) {
+        return this.parts.every((v, i) => v === parts[i]);
+    }
+    /**
+     * For the average case the string representation is provided, but
+     * when we need to convert high and low to string we just let the
+     * slower big-integer library do it.
+     */
+    toString() {
+        if (this.str != null) {
+            return this.str;
+        }
+        const array = new Array(MAX_BIG_INT / 4);
+        this.parts.forEach((value, offset) => {
+            const hex = toHexReverseArray(value.toString());
+            for (let i = 0; i < 4; i++) {
+                array[i + offset * 4] = hex[4 - 1 - i] || 0;
+            }
+        });
+        return (this.str = BigInteger.default.fromArray(array, 16).toString());
+    }
+    toJSON() {
+        return this.toString();
+    }
+}
+const SUPPORTS_BIGINT = checkBrowserSupportsBigInt();
+// Polyfill toJSON on BigInt if necessary.
+if (SUPPORTS_BIGINT && BigInt.prototype.toJSON == null) {
+    BigInt.prototype.toJSON = function () {
+        return this.toString();
+    };
+}
+const HIGH_LOW_CACHE = {};
+const convertToBigFlag = SUPPORTS_BIGINT
+    ? function convertToBigFlagBigInt(value) {
+        return BigInt(value);
+    }
+    : function convertToBigFlagHighLow(value) {
+        if (value instanceof HighLow) {
+            return value;
+        }
+        if (typeof value === 'number') {
+            value = value.toString();
+        }
+        // These type assertions are ugly, but there doesn't seem to be a
+        // runtime costless way to do a type assertion above.
+        if (HIGH_LOW_CACHE[value] != null) {
+            return HIGH_LOW_CACHE[value];
+        }
+        HIGH_LOW_CACHE[value] = HighLow.fromString(value);
+        return HIGH_LOW_CACHE[value];
+    };
+const EMPTY_FLAG = convertToBigFlag(0);
+const flagAnd = SUPPORTS_BIGINT
+    ? function flagAndBigInt(first = EMPTY_FLAG, second = EMPTY_FLAG) {
+        return first & second;
+    }
+    : function flagAndHighLow(first = EMPTY_FLAG, second = EMPTY_FLAG) {
+        return first.and(second);
+    };
+const flagOr = SUPPORTS_BIGINT
+    ? function flagOrBigInt(first = EMPTY_FLAG, second = EMPTY_FLAG) {
+        return first | second;
+    }
+    : function flagOrHighLow(first = EMPTY_FLAG, second = EMPTY_FLAG) {
+        return first.or(second);
+    };
+const flagXor = SUPPORTS_BIGINT
+    ? function flagXorBigInt(first = EMPTY_FLAG, second = EMPTY_FLAG) {
+        return first ^ second;
+    }
+    : function flagXorHighLow(first = EMPTY_FLAG, second = EMPTY_FLAG) {
+        return first.xor(second);
+    };
+const flagNot = SUPPORTS_BIGINT
+    ? function flagNotBigInt(first = EMPTY_FLAG) {
+        return ~first;
+    }
+    : function flagNotHighLow(first = EMPTY_FLAG) {
+        return first.not();
+    };
+const flagEquals = SUPPORTS_BIGINT
+    ? function flagEqualsBigInt(first, second) {
+        return first === second;
+    }
+    : function flagEqualsHighLow(first, second) {
+        if (first == null || second == null) {
+            // eslint-disable-next-line eqeqeq
+            return first == second;
+        }
+        return first.equals(second);
+    };
+function flagOrMultiple(...flags) {
+    let result = flags[0];
+    for (let i = 1; i < flags.length; i++) {
+        result = flagOr(result, flags[i]);
+    }
+    return result;
+}
+function flagHas(base, flag) {
+    return flagEquals(flagAnd(base, flag), flag);
+}
+function flagHasAny(base, flag) {
+    return !flagEquals(flagAnd(base, flag), EMPTY_FLAG);
+}
+function flagAdd(base, flag) {
+    return flag === EMPTY_FLAG ? base : flagOr(base, flag);
+}
+function flagRemove(base, flag) {
+    return flag === EMPTY_FLAG ? base : flagXor(base, flagAnd(base, flag));
+}
+const getFlag = SUPPORTS_BIGINT
+    ? function getFlagBigInt(index) {
+        return BigInt(1) << BigInt(index);
+    }
+    : function getFlagHighLow(index) {
+        return HighLow.fromBit(index);
+    };
+var BigFlagUtils = {
+    combine: flagOrMultiple,
+    add: flagAdd,
+    remove: flagRemove,
+    filter: flagAnd,
+    invert: flagNot,
+    has: flagHas,
+    hasAny: flagHasAny,
+    equals: flagEquals,
+    deserialize: convertToBigFlag,
+    getFlag: getFlag,
+};
+
+exports.default = BigFlagUtils;

package/node_modules/@discord/embedded-app-sdk/output/utils/BigFlagUtils.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Context: Due to Discord supporting more than 32 permissions, permission calculation has become more complicated than naive
+ * bit operations on `number`s. To support this generically, we have created BigFlagUtils to work with bit-flags greater
+ * than 32-bits in size.
+ *
+ * Ideally, we would like to use BigInt, which is pretty efficient, but some JavaScript engines do not support it.
+ *
+ * This file is intended to be a set of lower-level operators that act directly on "BigFlags".
+ *
+ * If you're working with permissions, in most cases you can probably use PermissionUtils.
+ */
+declare class HighLow {
+    parts: number[];
+    str: string | undefined;
+    static fromString(value: string): HighLow;
+    static fromBit(index: number): HighLow;
+    constructor(parts: number[], str?: string);
+    and({ parts }: HighLow): HighLow;
+    or({ parts }: HighLow): HighLow;
+    xor({ parts }: HighLow): HighLow;
+    not(): HighLow;
+    equals({ parts }: HighLow): boolean;
+    /**
+     * For the average case the string representation is provided, but
+     * when we need to convert high and low to string we just let the
+     * slower big-integer library do it.
+     */
+    toString(): string;
+    toJSON(): string;
+}
+declare global {
+    interface BigInt {
+        toJSON(): string;
+    }
+}
+/**
+ * Technically, it should be one or the other, but Typescript doesn't seem
+ * to have the power to express that dynamically yet.
+ */
+export type BigFlag = bigint | HighLow;
+export declare const isBigFlag: (value: any) => value is BigFlag;
+declare function flagOrMultiple(...flags: BigFlag[]): BigFlag;
+declare function flagHas(base: BigFlag, flag: BigFlag): boolean;
+declare function flagHasAny(base: BigFlag, flag: BigFlag): boolean;
+declare function flagAdd(base: BigFlag, flag: BigFlag): BigFlag;
+declare function flagRemove(base: BigFlag, flag: BigFlag): BigFlag;
+declare const _default: {
+    combine: typeof flagOrMultiple;
+    add: typeof flagAdd;
+    remove: typeof flagRemove;
+    filter: (first: BigFlag, second: BigFlag) => BigFlag;
+    invert: (first: BigFlag | undefined) => BigFlag;
+    has: typeof flagHas;
+    hasAny: typeof flagHasAny;
+    equals: (first: BigFlag | undefined, second: BigFlag | undefined) => boolean;
+    deserialize: (value: number | string | BigFlag) => BigFlag;
+    getFlag: (index: number) => BigFlag;
+};
+export default _default;