@relayapi/sdk 0.2.2

package/dist/internal/utils/base64.d.ts

@@ -0,0 +1,2 @@
+export declare const toBase64: (data: string | Uint8Array | null | undefined) => string;
+export declare const fromBase64: (str: string) => Uint8Array;

package/dist/internal/utils/base64.js

@@ -0,0 +1,37 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64 = exports.toBase64 = void 0;
+const error_1 = require("../../core/error");
+const bytes_1 = require("./bytes");
+const toBase64 = (data) => {
+    if (!data)
+        return '';
+    if (typeof globalThis.Buffer !== 'undefined') {
+        return globalThis.Buffer.from(data).toString('base64');
+    }
+    if (typeof data === 'string') {
+        data = (0, bytes_1.encodeUTF8)(data);
+    }
+    if (typeof btoa !== 'undefined') {
+        return btoa(String.fromCharCode.apply(null, data));
+    }
+    throw new error_1.RelayError('Cannot generate base64 string; Expected `Buffer` or `btoa` to be defined');
+};
+exports.toBase64 = toBase64;
+const fromBase64 = (str) => {
+    if (typeof globalThis.Buffer !== 'undefined') {
+        const buf = globalThis.Buffer.from(str, 'base64');
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    if (typeof atob !== 'undefined') {
+        const bstr = atob(str);
+        const buf = new Uint8Array(bstr.length);
+        for (let i = 0; i < bstr.length; i++) {
+            buf[i] = bstr.charCodeAt(i);
+        }
+        return buf;
+    }
+    throw new error_1.RelayError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');
+};
+exports.fromBase64 = fromBase64;

package/dist/internal/utils/bytes.d.ts

@@ -0,0 +1,3 @@
+export declare function concatBytes(buffers: Uint8Array[]): Uint8Array;
+export declare function encodeUTF8(str: string): Uint8Array<ArrayBufferLike>;
+export declare function decodeUTF8(bytes: Uint8Array): string;

package/dist/internal/utils/bytes.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatBytes = concatBytes;
+exports.encodeUTF8 = encodeUTF8;
+exports.decodeUTF8 = decodeUTF8;
+function concatBytes(buffers) {
+    let length = 0;
+    for (const buffer of buffers) {
+        length += buffer.length;
+    }
+    const output = new Uint8Array(length);
+    let index = 0;
+    for (const buffer of buffers) {
+        output.set(buffer, index);
+        index += buffer.length;
+    }
+    return output;
+}
+let encodeUTF8_;
+function encodeUTF8(str) {
+    let encoder;
+    return (encodeUTF8_ ??
+        ((encoder = new globalThis.TextEncoder()), (encodeUTF8_ = encoder.encode.bind(encoder))))(str);
+}
+let decodeUTF8_;
+function decodeUTF8(bytes) {
+    let decoder;
+    return (decodeUTF8_ ??
+        ((decoder = new globalThis.TextDecoder()), (decodeUTF8_ = decoder.decode.bind(decoder))))(bytes);
+}

package/dist/internal/utils/env.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Read an environment variable.
+ *
+ * Trims beginning and trailing whitespace.
+ *
+ * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ */
+export declare const readEnv: (env: string) => string | undefined;

package/dist/internal/utils/env.js

@@ -0,0 +1,21 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEnv = void 0;
+/**
+ * Read an environment variable.
+ *
+ * Trims beginning and trailing whitespace.
+ *
+ * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ */
+const readEnv = (env) => {
+    if (typeof globalThis.process !== 'undefined') {
+        return globalThis.process.env?.[env]?.trim() ?? undefined;
+    }
+    if (typeof globalThis.Deno !== 'undefined') {
+        return globalThis.Deno.env?.get?.(env)?.trim();
+    }
+    return undefined;
+};
+exports.readEnv = readEnv;

package/dist/internal/utils/log.d.ts

@@ -0,0 +1,36 @@
+import { type Relay } from '../../client';
+import { RequestOptions } from '../request-options';
+type LogFn = (message: string, ...rest: unknown[]) => void;
+export type Logger = {
+    error: LogFn;
+    warn: LogFn;
+    info: LogFn;
+    debug: LogFn;
+};
+export type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug';
+export declare const parseLogLevel: (maybeLevel: string | undefined, sourceName: string, client: Relay) => LogLevel | undefined;
+export declare function loggerFor(client: Relay): Logger;
+export declare const formatRequestDetails: (details: {
+    options?: RequestOptions | undefined;
+    headers?: Headers | Record<string, string> | undefined;
+    retryOfRequestLogID?: string | undefined;
+    retryOf?: string | undefined;
+    url?: string | undefined;
+    status?: number | undefined;
+    method?: string | undefined;
+    durationMs?: number | undefined;
+    message?: unknown;
+    body?: unknown;
+}) => {
+    options?: RequestOptions | undefined;
+    headers?: Headers | Record<string, string> | undefined;
+    retryOfRequestLogID?: string | undefined;
+    retryOf?: string | undefined;
+    url?: string | undefined;
+    status?: number | undefined;
+    method?: string | undefined;
+    durationMs?: number | undefined;
+    message?: unknown;
+    body?: unknown;
+};
+export {};

package/dist/internal/utils/log.js

@@ -0,0 +1,84 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRequestDetails = exports.parseLogLevel = void 0;
+exports.loggerFor = loggerFor;
+const values_1 = require("./values");
+const levelNumbers = {
+    off: 0,
+    error: 200,
+    warn: 300,
+    info: 400,
+    debug: 500,
+};
+const parseLogLevel = (maybeLevel, sourceName, client) => {
+    if (!maybeLevel) {
+        return undefined;
+    }
+    if ((0, values_1.hasOwn)(levelNumbers, maybeLevel)) {
+        return maybeLevel;
+    }
+    loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`);
+    return undefined;
+};
+exports.parseLogLevel = parseLogLevel;
+function noop() { }
+function makeLogFn(fnLevel, logger, logLevel) {
+    if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) {
+        return noop;
+    }
+    else {
+        // Don't wrap logger functions, we want the stacktrace intact!
+        return logger[fnLevel].bind(logger);
+    }
+}
+const noopLogger = {
+    error: noop,
+    warn: noop,
+    info: noop,
+    debug: noop,
+};
+let cachedLoggers = /* @__PURE__ */ new WeakMap();
+function loggerFor(client) {
+    const logger = client.logger;
+    const logLevel = client.logLevel ?? 'off';
+    if (!logger) {
+        return noopLogger;
+    }
+    const cachedLogger = cachedLoggers.get(logger);
+    if (cachedLogger && cachedLogger[0] === logLevel) {
+        return cachedLogger[1];
+    }
+    const levelLogger = {
+        error: makeLogFn('error', logger, logLevel),
+        warn: makeLogFn('warn', logger, logLevel),
+        info: makeLogFn('info', logger, logLevel),
+        debug: makeLogFn('debug', logger, logLevel),
+    };
+    cachedLoggers.set(logger, [logLevel, levelLogger]);
+    return levelLogger;
+}
+const formatRequestDetails = (details) => {
+    if (details.options) {
+        details.options = { ...details.options };
+        delete details.options['headers']; // redundant + leaks internals
+    }
+    if (details.headers) {
+        details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [
+            name,
+            (name.toLowerCase() === 'authorization' ||
+                name.toLowerCase() === 'cookie' ||
+                name.toLowerCase() === 'set-cookie') ?
+                '***'
+                : value,
+        ]));
+    }
+    if ('retryOfRequestLogID' in details) {
+        if (details.retryOfRequestLogID) {
+            details.retryOf = details.retryOfRequestLogID;
+        }
+        delete details.retryOfRequestLogID;
+    }
+    return details;
+};
+exports.formatRequestDetails = formatRequestDetails;

package/dist/internal/utils/path.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+export declare function encodeURIPath(str: string): string;
+export declare const createPathTagFunction: (pathEncoder?: typeof encodeURIPath) => (statics: readonly string[], ...params: readonly unknown[]) => string;
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+export declare const path: (statics: readonly string[], ...params: readonly unknown[]) => string;

package/dist/internal/utils/path.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.path = exports.createPathTagFunction = void 0;
+exports.encodeURIPath = encodeURIPath;
+const error_1 = require("../../core/error");
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+function encodeURIPath(str) {
+    return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+const EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
+const createPathTagFunction = (pathEncoder = encodeURIPath) => function path(statics, ...params) {
+    // If there are no params, no processing is needed.
+    if (statics.length === 1)
+        return statics[0];
+    let postPath = false;
+    const invalidSegments = [];
+    const path = statics.reduce((previousValue, currentValue, index) => {
+        if (/[?#]/.test(currentValue)) {
+            postPath = true;
+        }
+        const value = params[index];
+        let encoded = (postPath ? encodeURIComponent : pathEncoder)('' + value);
+        if (index !== params.length &&
+            (value == null ||
+                (typeof value === 'object' &&
+                    // handle values from other realms
+                    value.toString ===
+                        Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY)
+                            ?.toString))) {
+            encoded = value + '';
+            invalidSegments.push({
+                start: previousValue.length + currentValue.length,
+                length: encoded.length,
+                error: `Value of type ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)} is not a valid path parameter`,
+            });
+        }
+        return previousValue + currentValue + (index === params.length ? '' : encoded);
+    }, '');
+    const pathOnly = path.split(/[?#]/, 1)[0];
+    const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+    let match;
+    // Find all invalid segments
+    while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+        invalidSegments.push({
+            start: match.index,
+            length: match[0].length,
+            error: `Value "${match[0]}" can\'t be safely passed as a path parameter`,
+        });
+    }
+    invalidSegments.sort((a, b) => a.start - b.start);
+    if (invalidSegments.length > 0) {
+        let lastEnd = 0;
+        const underline = invalidSegments.reduce((acc, segment) => {
+            const spaces = ' '.repeat(segment.start - lastEnd);
+            const arrows = '^'.repeat(segment.length);
+            lastEnd = segment.start + segment.length;
+            return acc + spaces + arrows;
+        }, '');
+        throw new error_1.RelayError(`Path parameters result in path with invalid segments:\n${invalidSegments
+            .map((e) => e.error)
+            .join('\n')}\n${path}\n${underline}`);
+    }
+    return path;
+};
+exports.createPathTagFunction = createPathTagFunction;
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+exports.path = (0, exports.createPathTagFunction)(encodeURIPath);

package/dist/internal/utils/query.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Basic re-implementation of `qs.stringify` for primitive types.
+ */
+export declare function stringifyQuery(query: object | Record<string, unknown>): string;

package/dist/internal/utils/query.js

@@ -0,0 +1,22 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyQuery = stringifyQuery;
+const error_1 = require("../../core/error");
+/**
+ * Basic re-implementation of `qs.stringify` for primitive types.
+ */
+function stringifyQuery(query) {
+    return Object.entries(query)
+        .filter(([_, value]) => typeof value !== 'undefined')
+        .map(([key, value]) => {
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+        }
+        if (value === null) {
+            return `${encodeURIComponent(key)}=`;
+        }
+        throw new error_1.RelayError(`Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
+    })
+        .join('&');
+}

package/dist/internal/utils/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/internal/utils/sleep.js

@@ -0,0 +1,6 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.sleep = sleep;

package/dist/internal/utils/uuid.d.ts

@@ -0,0 +1,4 @@
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export declare let uuid4: () => any;

package/dist/internal/utils/uuid.js

@@ -0,0 +1,18 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid4 = void 0;
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+let uuid4 = function () {
+    const { crypto } = globalThis;
+    if (crypto?.randomUUID) {
+        exports.uuid4 = crypto.randomUUID.bind(crypto);
+        return crypto.randomUUID();
+    }
+    const u8 = new Uint8Array(1);
+    const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => (Math.random() * 0xff) & 0xff;
+    return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) => (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16));
+};
+exports.uuid4 = uuid4;

package/dist/internal/utils/values.d.ts

@@ -0,0 +1,17 @@
+export declare const isAbsoluteURL: (url: string) => boolean;
+export declare let isArray: (val: unknown) => val is unknown[];
+export declare let isReadonlyArray: (val: unknown) => val is readonly unknown[];
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export declare function maybeObj(x: unknown): object;
+export declare function isEmptyObj(obj: Object | null | undefined): boolean;
+export declare function hasOwn<T extends object = object>(obj: T, key: PropertyKey): key is keyof T;
+export declare function isObj(obj: unknown): obj is Record<string, unknown>;
+export declare const ensurePresent: <T>(value: T | null | undefined) => T;
+export declare const validatePositiveInteger: (name: string, n: unknown) => number;
+export declare const coerceInteger: (value: unknown) => number;
+export declare const coerceFloat: (value: unknown) => number;
+export declare const coerceBoolean: (value: unknown) => boolean;
+export declare const maybeCoerceInteger: (value: unknown) => number | undefined;
+export declare const maybeCoerceFloat: (value: unknown) => number | undefined;
+export declare const maybeCoerceBoolean: (value: unknown) => boolean | undefined;
+export declare const safeJSON: (text: string) => any;

package/dist/internal/utils/values.js

@@ -0,0 +1,111 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeJSON = exports.maybeCoerceBoolean = exports.maybeCoerceFloat = exports.maybeCoerceInteger = exports.coerceBoolean = exports.coerceFloat = exports.coerceInteger = exports.validatePositiveInteger = exports.ensurePresent = exports.isReadonlyArray = exports.isArray = exports.isAbsoluteURL = void 0;
+exports.maybeObj = maybeObj;
+exports.isEmptyObj = isEmptyObj;
+exports.hasOwn = hasOwn;
+exports.isObj = isObj;
+const error_1 = require("../../core/error");
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+const isAbsoluteURL = (url) => {
+    return startsWithSchemeRegexp.test(url);
+};
+exports.isAbsoluteURL = isAbsoluteURL;
+let isArray = (val) => ((exports.isArray = Array.isArray), (0, exports.isArray)(val));
+exports.isArray = isArray;
+exports.isReadonlyArray = exports.isArray;
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+function maybeObj(x) {
+    if (typeof x !== 'object') {
+        return {};
+    }
+    return x ?? {};
+}
+// https://stackoverflow.com/a/34491287
+function isEmptyObj(obj) {
+    if (!obj)
+        return true;
+    for (const _k in obj)
+        return false;
+    return true;
+}
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isObj(obj) {
+    return obj != null && typeof obj === 'object' && !Array.isArray(obj);
+}
+const ensurePresent = (value) => {
+    if (value == null) {
+        throw new error_1.RelayError(`Expected a value to be given but received ${value} instead.`);
+    }
+    return value;
+};
+exports.ensurePresent = ensurePresent;
+const validatePositiveInteger = (name, n) => {
+    if (typeof n !== 'number' || !Number.isInteger(n)) {
+        throw new error_1.RelayError(`${name} must be an integer`);
+    }
+    if (n < 0) {
+        throw new error_1.RelayError(`${name} must be a positive integer`);
+    }
+    return n;
+};
+exports.validatePositiveInteger = validatePositiveInteger;
+const coerceInteger = (value) => {
+    if (typeof value === 'number')
+        return Math.round(value);
+    if (typeof value === 'string')
+        return parseInt(value, 10);
+    throw new error_1.RelayError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+exports.coerceInteger = coerceInteger;
+const coerceFloat = (value) => {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string')
+        return parseFloat(value);
+    throw new error_1.RelayError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+exports.coerceFloat = coerceFloat;
+const coerceBoolean = (value) => {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string')
+        return value === 'true';
+    return Boolean(value);
+};
+exports.coerceBoolean = coerceBoolean;
+const maybeCoerceInteger = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    return (0, exports.coerceInteger)(value);
+};
+exports.maybeCoerceInteger = maybeCoerceInteger;
+const maybeCoerceFloat = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    return (0, exports.coerceFloat)(value);
+};
+exports.maybeCoerceFloat = maybeCoerceFloat;
+const maybeCoerceBoolean = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    return (0, exports.coerceBoolean)(value);
+};
+exports.maybeCoerceBoolean = maybeCoerceBoolean;
+const safeJSON = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        return undefined;
+    }
+};
+exports.safeJSON = safeJSON;

package/dist/internal/utils.d.ts

@@ -0,0 +1,7 @@
+export * from './utils/values';
+export * from './utils/base64';
+export * from './utils/env';
+export * from './utils/log';
+export * from './utils/uuid';
+export * from './utils/sleep';
+export * from './utils/query';

package/dist/internal/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils/values"), exports);
+__exportStar(require("./utils/base64"), exports);
+__exportStar(require("./utils/env"), exports);
+__exportStar(require("./utils/log"), exports);
+__exportStar(require("./utils/uuid"), exports);
+__exportStar(require("./utils/sleep"), exports);
+__exportStar(require("./utils/query"), exports);

package/dist/resource.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/resource instead */
+export * from './core/resource';

package/dist/resource.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @deprecated Import from ./core/resource instead */
+__exportStar(require("./core/resource"), exports);

package/dist/resources/account-groups.d.ts

@@ -0,0 +1,52 @@
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+export declare class AccountGroups extends APIResource {
+    /**
+     * Create an account group
+     */
+    create(body: AccountGroupCreateParams, options?: RequestOptions): APIPromise<AccountGroupCreateResponse>;
+    /**
+     * Update an account group
+     */
+    update(id: string, body?: AccountGroupUpdateParams | null | undefined, options?: RequestOptions): APIPromise<AccountGroupUpdateResponse>;
+    /**
+     * List account groups
+     */
+    list(query?: AccountGroupListParams, options?: RequestOptions): APIPromise<AccountGroupListResponse>;
+    /**
+     * Delete an account group
+     */
+    delete(id: string, options?: RequestOptions): APIPromise<void>;
+}
+export interface AccountGroupResponse {
+    id: string;
+    name: string;
+    description: string | null;
+    account_count: number;
+    created_at: string;
+    updated_at: string;
+}
+export type AccountGroupCreateResponse = AccountGroupResponse;
+export type AccountGroupUpdateResponse = AccountGroupResponse;
+export interface AccountGroupListResponse {
+    data: Array<AccountGroupResponse>;
+    next_cursor: string | null;
+    has_more: boolean;
+}
+export interface AccountGroupCreateParams {
+    name: string;
+    description?: string;
+}
+export interface AccountGroupUpdateParams {
+    name?: string;
+    description?: string | null;
+}
+export interface AccountGroupListParams {
+    search?: string;
+    limit?: number;
+    cursor?: string;
+}
+export declare namespace AccountGroups {
+    export { type AccountGroupResponse as AccountGroupResponse, type AccountGroupCreateResponse as AccountGroupCreateResponse, type AccountGroupUpdateResponse as AccountGroupUpdateResponse, type AccountGroupListResponse as AccountGroupListResponse, type AccountGroupCreateParams as AccountGroupCreateParams, type AccountGroupUpdateParams as AccountGroupUpdateParams, type AccountGroupListParams as AccountGroupListParams, };
+}