rehive 3.1.4 → 4.1.0

package/dist/extensions/alchemy.d.mts

@@ -0,0 +1,1114 @@
+import { A as ApiFactoryConfig, B as BoundSdk } from '../create-api-client-2vNCP2LN.mjs';
+import '../create-auth-CHzmb_8_.mjs';
+
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: any) => any;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g. converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'data', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'data', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'data'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    request: Request;
+    response: Response;
+}>;
+interface ClientOptions$1 {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'data'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'data'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'data'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options$1<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'data'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
+type ClientOptions = {
+    baseUrl: 'https://alchemy.services.rehive.com/api/' | (string & {});
+};
+/**
+ * Serializer for looking up a crypto address from a Rehive account reference.
+ */
+type AccountAddressLookup = {
+    account: string;
+    readonly address: string;
+};
+type AccountAddressLookupResponse = {
+    status?: string;
+    data?: AccountAddressLookup;
+};
+/**
+ * This serializer can be used if only a `status` is required in the response.
+ */
+type ActionResponse = {
+    status?: string;
+};
+/**
+ * Serialize the activation data, should be a token that represents an admin
+ * user.
+ */
+type Activate = {
+    token: string;
+    readonly id: string;
+    readonly name: string;
+    readonly secret: string;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type Address = {
+    readonly identifier: string;
+    address: string;
+    user: User;
+    rehive_account: string;
+    readonly created: number;
+    readonly updated: number;
+};
+type AddressResponse = {
+    status?: string;
+    data?: Address;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminAddress = {
+    readonly id: string;
+    readonly address: string;
+    readonly rehive_account: string;
+    user: User;
+    readonly created: number;
+    readonly updated: number;
+};
+type AdminAddressResponse = {
+    status?: string;
+    data?: AdminAddress;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminCompany = {
+    readonly id: string;
+    readonly secret: string;
+    readonly name: string;
+    /**
+     * * `test` - Test
+     * * `production` - Production
+     */
+    mode: 'test' | 'production';
+    alchemy_key?: string | null;
+};
+type AdminCompanyResponse = {
+    status?: string;
+    data?: AdminCompany;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminOnchainTransaction = {
+    readonly id: string;
+    readonly hash: string;
+    /**
+     * * `pending` - Pending
+     * * `signed` - Signed
+     * * `broadcast` - Broadcast
+     * * `confirmed` - Confirmed
+     * * `failed` - Failed
+     * * `cancelled` - Cancelled
+     */
+    status: 'pending' | 'signed' | 'broadcast' | 'confirmed' | 'failed' | 'cancelled';
+    /**
+     * * `ETH_SEPOLIA` - Eth Sepolia
+     * * `ETH_MAINNET` - Eth Mainnet
+     * * `BASE_MAINNET` - Base Mainnet
+     * * `BASE_SEPOLIA` - Base Sepolia
+     */
+    chain: 'ETH_SEPOLIA' | 'ETH_MAINNET' | 'BASE_MAINNET' | 'BASE_SEPOLIA';
+    readonly from_address: string;
+    readonly destination_address: string;
+    readonly amount: string;
+    readonly rehive_transaction_id: string;
+    readonly unsigned_transaction_blob: unknown;
+    currency: Currency;
+    address: AdminAddress;
+    readonly created: number;
+    readonly updated: number;
+};
+type AdminOnchainTransactionResponse = {
+    status?: string;
+    data?: AdminOnchainTransaction;
+};
+type AlchemyWebhook = {
+    event: unknown;
+    createdAt: string;
+    type: string;
+    webhookId: string;
+    id: string;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type Currency = {
+    readonly code: string;
+    /**
+     * * `USDC` - Usdc
+     * * `ETH` - Eth
+     */
+    onchain_code: 'USDC' | 'ETH';
+    /**
+     * * `ETH_SEPOLIA` - Eth Sepolia
+     * * `ETH_MAINNET` - Eth Mainnet
+     * * `BASE_MAINNET` - Base Mainnet
+     * * `BASE_SEPOLIA` - Base Sepolia
+     */
+    chain: 'ETH_SEPOLIA' | 'ETH_MAINNET' | 'BASE_MAINNET' | 'BASE_SEPOLIA';
+    readonly token_address: string;
+    readonly display_code: string;
+    readonly description: string;
+    readonly symbol: string;
+    readonly unit: string;
+    readonly divisibility: number;
+};
+/**
+ * Serialize the deactivation data, should be a token that represents an admin
+ * user.
+ */
+type Deactivate = {
+    token: string;
+    purge?: boolean;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type OnchainTransaction = {
+    readonly identifier: string;
+    hash?: string | null;
+    /**
+     * * `pending` - Pending
+     * * `signed` - Signed
+     * * `broadcast` - Broadcast
+     * * `confirmed` - Confirmed
+     * * `failed` - Failed
+     * * `cancelled` - Cancelled
+     */
+    status: 'pending' | 'signed' | 'broadcast' | 'confirmed' | 'failed' | 'cancelled';
+    /**
+     * * `ETH_SEPOLIA` - Eth Sepolia
+     * * `ETH_MAINNET` - Eth Mainnet
+     * * `BASE_MAINNET` - Base Mainnet
+     * * `BASE_SEPOLIA` - Base Sepolia
+     */
+    chain: 'ETH_SEPOLIA' | 'ETH_MAINNET' | 'BASE_MAINNET' | 'BASE_SEPOLIA';
+    readonly from_address: string;
+    readonly destination_address: string;
+    readonly amount: string;
+    readonly rehive_transaction_id: string;
+    readonly unsigned_transaction_blob: unknown;
+    currency: Currency;
+    readonly created: number;
+    readonly updated: number;
+};
+type OnchainTransactionResponse = {
+    status?: string;
+    data?: OnchainTransaction;
+};
+type PaginatedAddressList = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<Address>;
+};
+type PaginatedAddressListResponse = {
+    status?: string;
+    data?: PaginatedAddressList;
+};
+type PaginatedAdminAddressList = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<AdminAddress>;
+};
+type PaginatedAdminAddressListResponse = {
+    status?: string;
+    data?: PaginatedAdminAddressList;
+};
+type PaginatedAdminOnchainTransactionList = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<AdminOnchainTransaction>;
+};
+type PaginatedAdminOnchainTransactionListResponse = {
+    status?: string;
+    data?: PaginatedAdminOnchainTransactionList;
+};
+type PaginatedOnchainTransactionList = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<OnchainTransaction>;
+};
+type PaginatedOnchainTransactionListResponse = {
+    status?: string;
+    data?: PaginatedOnchainTransactionList;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type PatchedAdminCompany = {
+    readonly id?: string;
+    readonly secret?: string;
+    readonly name?: string;
+    /**
+     * * `test` - Test
+     * * `production` - Production
+     */
+    mode?: 'test' | 'production';
+    alchemy_key?: string | null;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type PatchedOnchainTransaction = {
+    readonly identifier?: string;
+    hash?: string | null;
+    /**
+     * * `pending` - Pending
+     * * `signed` - Signed
+     * * `broadcast` - Broadcast
+     * * `confirmed` - Confirmed
+     * * `failed` - Failed
+     * * `cancelled` - Cancelled
+     */
+    status?: 'pending' | 'signed' | 'broadcast' | 'confirmed' | 'failed' | 'cancelled';
+    /**
+     * * `ETH_SEPOLIA` - Eth Sepolia
+     * * `ETH_MAINNET` - Eth Mainnet
+     * * `BASE_MAINNET` - Base Mainnet
+     * * `BASE_SEPOLIA` - Base Sepolia
+     */
+    chain?: 'ETH_SEPOLIA' | 'ETH_MAINNET' | 'BASE_MAINNET' | 'BASE_SEPOLIA';
+    readonly from_address?: string;
+    readonly destination_address?: string;
+    readonly amount?: string;
+    readonly rehive_transaction_id?: string;
+    readonly unsigned_transaction_blob?: unknown;
+    currency?: Currency;
+    readonly created?: number;
+    readonly updated?: number;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type User = {
+    identifier: string;
+};
+type Webhook = {
+    id: string;
+    /**
+     * * `account.currency.create` - Account Currency Create
+     * * `bank_account.create` - Bank Account Create
+     * * `bank_account.update` - Bank Account Update
+     * * `bank_account.delete` - Bank Account Delete
+     * * `currency.create` - Currency Create
+     * * `currency.update` - Currency Update
+     * * `transaction.initiate` - Transaction Initiate
+     * * `transaction.transition.update` - Transaction Transition Update
+     * * `user.update` - User Update
+     */
+    event: 'account.currency.create' | 'bank_account.create' | 'bank_account.update' | 'bank_account.delete' | 'currency.create' | 'currency.update' | 'transaction.initiate' | 'transaction.transition.update' | 'user.update';
+    company: string;
+    data: unknown;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AddressWritable = {
+    address: string;
+    rehive_account: string;
+};
+type AddressResponseWritable = {
+    status?: string;
+    data?: AddressWritable;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminAddressWritable = {
+    [key: string]: unknown;
+};
+type AdminAddressResponseWritable = {
+    status?: string;
+    data?: AdminAddressWritable;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminCompanyWritable = {
+    alchemy_key?: string | null;
+};
+type AdminCompanyResponseWritable = {
+    status?: string;
+    data?: AdminCompanyWritable;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type AdminOnchainTransactionWritable = {
+    [key: string]: unknown;
+};
+type AdminOnchainTransactionResponseWritable = {
+    status?: string;
+    data?: AdminOnchainTransactionWritable;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type OnchainTransactionWritable = {
+    hash?: string | null;
+    /**
+     * * `pending` - Pending
+     * * `signed` - Signed
+     * * `broadcast` - Broadcast
+     * * `confirmed` - Confirmed
+     * * `failed` - Failed
+     * * `cancelled` - Cancelled
+     */
+    status: 'pending' | 'signed' | 'broadcast' | 'confirmed' | 'failed' | 'cancelled';
+};
+type OnchainTransactionResponseWritable = {
+    status?: string;
+    data?: OnchainTransactionWritable;
+};
+type PaginatedAddressListWritable = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<AddressWritable>;
+};
+type PaginatedAddressListResponseWritable = {
+    status?: string;
+    data?: PaginatedAddressListWritable;
+};
+type PaginatedAdminAddressListWritable = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<AdminAddressWritable>;
+};
+type PaginatedAdminAddressListResponseWritable = {
+    status?: string;
+    data?: PaginatedAdminAddressListWritable;
+};
+type PaginatedAdminOnchainTransactionListWritable = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<AdminOnchainTransactionWritable>;
+};
+type PaginatedAdminOnchainTransactionListResponseWritable = {
+    status?: string;
+    data?: PaginatedAdminOnchainTransactionListWritable;
+};
+type PaginatedOnchainTransactionListWritable = {
+    count: number;
+    next?: string | null;
+    previous?: string | null;
+    results: Array<OnchainTransactionWritable>;
+};
+type PaginatedOnchainTransactionListResponseWritable = {
+    status?: string;
+    data?: PaginatedOnchainTransactionListWritable;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type PatchedAdminCompanyWritable = {
+    alchemy_key?: string | null;
+};
+/**
+ * A ModelSerializer that takes additional arguments for
+ * "fields", "omit" and "expand" in order to
+ * control which fields are displayed, and whether to replace simple
+ * values with complex, nested serializations
+ */
+type PatchedOnchainTransactionWritable = {
+    hash?: string | null;
+    /**
+     * * `pending` - Pending
+     * * `signed` - Signed
+     * * `broadcast` - Broadcast
+     * * `confirmed` - Confirmed
+     * * `failed` - Failed
+     * * `cancelled` - Cancelled
+     */
+    status?: 'pending' | 'signed' | 'broadcast' | 'confirmed' | 'failed' | 'cancelled';
+};
+type ActivateCreateData = {
+    body: Activate;
+    path?: never;
+    query?: never;
+    url: '/activate/';
+};
+type ActivateCreateResponses = {
+    200: ActionResponse;
+};
+type ActivateCreateResponse = ActivateCreateResponses[keyof ActivateCreateResponses];
+type AdminAddressesListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        address?: string;
+        /**
+         * A page number within the paginated result set.
+         */
+        page?: number;
+        /**
+         * Number of results to return per page.
+         */
+        page_size?: number;
+        rehive_account?: string;
+        user?: string;
+    };
+    url: '/admin/addresses/';
+};
+type AdminAddressesListResponses = {
+    200: PaginatedAdminAddressListResponse;
+};
+type AdminAddressesListResponse = AdminAddressesListResponses[keyof AdminAddressesListResponses];
+type AdminAddressesRetrieveData = {
+    body?: never;
+    path: {
+        identifier: string;
+    };
+    query?: never;
+    url: '/admin/addresses/{identifier}/';
+};
+type AdminAddressesRetrieveResponses = {
+    200: AdminAddressResponse;
+};
+type AdminAddressesRetrieveResponse = AdminAddressesRetrieveResponses[keyof AdminAddressesRetrieveResponses];
+type AdminCompanyRetrieveData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/admin/company/';
+};
+type AdminCompanyRetrieveResponses = {
+    200: AdminCompanyResponse;
+};
+type AdminCompanyRetrieveResponse = AdminCompanyRetrieveResponses[keyof AdminCompanyRetrieveResponses];
+type AdminCompanyPartialUpdateData = {
+    body?: PatchedAdminCompanyWritable;
+    path?: never;
+    query?: never;
+    url: '/admin/company/';
+};
+type AdminCompanyPartialUpdateResponses = {
+    200: AdminCompanyResponse;
+};
+type AdminCompanyPartialUpdateResponse = AdminCompanyPartialUpdateResponses[keyof AdminCompanyPartialUpdateResponses];
+type AdminCompanyUpdateData = {
+    body?: AdminCompanyWritable;
+    path?: never;
+    query?: never;
+    url: '/admin/company/';
+};
+type AdminCompanyUpdateResponses = {
+    200: AdminCompanyResponse;
+};
+type AdminCompanyUpdateResponse = AdminCompanyUpdateResponses[keyof AdminCompanyUpdateResponses];
+type AdminOnchainTransactionsListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        address?: string;
+        /**
+         * * `ETH_SEPOLIA` - ETH_SEPOLIA
+         * * `ETH_MAINNET` - ETH_MAINNET
+         * * `BASE_MAINNET` - BASE_MAINNET
+         * * `BASE_SEPOLIA` - BASE_SEPOLIA
+         */
+        chain?: 'BASE_MAINNET' | 'BASE_SEPOLIA' | 'ETH_MAINNET' | 'ETH_SEPOLIA';
+        destination_address?: string;
+        from_address?: string;
+        hash?: string;
+        /**
+         * A page number within the paginated result set.
+         */
+        page?: number;
+        /**
+         * Number of results to return per page.
+         */
+        page_size?: number;
+        rehive_transaction_id?: string;
+        /**
+         * * `pending` - pending
+         * * `signed` - signed
+         * * `broadcast` - broadcast
+         * * `confirmed` - confirmed
+         * * `failed` - failed
+         * * `cancelled` - cancelled
+         */
+        status?: 'broadcast' | 'cancelled' | 'confirmed' | 'failed' | 'pending' | 'signed';
+        user?: string;
+    };
+    url: '/admin/onchain-transactions/';
+};
+type AdminOnchainTransactionsListResponses = {
+    200: PaginatedAdminOnchainTransactionListResponse;
+};
+type AdminOnchainTransactionsListResponse = AdminOnchainTransactionsListResponses[keyof AdminOnchainTransactionsListResponses];
+type AdminOnchainTransactionsRetrieveData = {
+    body?: never;
+    path: {
+        identifier: string;
+    };
+    query?: never;
+    url: '/admin/onchain-transactions/{identifier}/';
+};
+type AdminOnchainTransactionsRetrieveResponses = {
+    200: AdminOnchainTransactionResponse;
+};
+type AdminOnchainTransactionsRetrieveResponse = AdminOnchainTransactionsRetrieveResponses[keyof AdminOnchainTransactionsRetrieveResponses];
+type AlchemyWebhookCreateData = {
+    body: AlchemyWebhook;
+    path?: never;
+    query?: never;
+    url: '/alchemy_webhook/';
+};
+type AlchemyWebhookCreateResponses = {
+    200: ActionResponse;
+};
+type AlchemyWebhookCreateResponse = AlchemyWebhookCreateResponses[keyof AlchemyWebhookCreateResponses];
+type DeactivateCreateData = {
+    body: Deactivate;
+    path?: never;
+    query?: never;
+    url: '/deactivate/';
+};
+type DeactivateCreateResponses = {
+    200: ActionResponse;
+};
+type DeactivateCreateResponse = DeactivateCreateResponses[keyof DeactivateCreateResponses];
+type UserAccountAddressLookupCreateData = {
+    body: AccountAddressLookup;
+    path?: never;
+    query?: never;
+    url: '/user/account-address-lookup/';
+};
+type UserAccountAddressLookupCreateResponses = {
+    200: AccountAddressLookupResponse;
+};
+type UserAccountAddressLookupCreateResponse = UserAccountAddressLookupCreateResponses[keyof UserAccountAddressLookupCreateResponses];
+type UserAddressesListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * A page number within the paginated result set.
+         */
+        page?: number;
+        /**
+         * Number of results to return per page.
+         */
+        page_size?: number;
+    };
+    url: '/user/addresses/';
+};
+type UserAddressesListResponses = {
+    200: PaginatedAddressListResponse;
+};
+type UserAddressesListResponse = UserAddressesListResponses[keyof UserAddressesListResponses];
+type UserAddressesCreateData = {
+    body: AddressWritable;
+    path?: never;
+    query?: never;
+    url: '/user/addresses/';
+};
+type UserAddressesCreateResponses = {
+    201: AddressResponse;
+};
+type UserAddressesCreateResponse = UserAddressesCreateResponses[keyof UserAddressesCreateResponses];
+type UserAddressesRetrieveData = {
+    body?: never;
+    path: {
+        identifier: string;
+    };
+    query?: never;
+    url: '/user/addresses/{identifier}/';
+};
+type UserAddressesRetrieveResponses = {
+    200: AddressResponse;
+};
+type UserAddressesRetrieveResponse = UserAddressesRetrieveResponses[keyof UserAddressesRetrieveResponses];
+type UserOnchainTransactionsListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * A page number within the paginated result set.
+         */
+        page?: number;
+        /**
+         * Number of results to return per page.
+         */
+        page_size?: number;
+    };
+    url: '/user/onchain-transactions/';
+};
+type UserOnchainTransactionsListResponses = {
+    200: PaginatedOnchainTransactionListResponse;
+};
+type UserOnchainTransactionsListResponse = UserOnchainTransactionsListResponses[keyof UserOnchainTransactionsListResponses];
+type UserOnchainTransactionsRetrieveData = {
+    body?: never;
+    path: {
+        identifier: string;
+    };
+    query?: never;
+    url: '/user/onchain-transactions/{identifier}/';
+};
+type UserOnchainTransactionsRetrieveResponses = {
+    200: OnchainTransactionResponse;
+};
+type UserOnchainTransactionsRetrieveResponse = UserOnchainTransactionsRetrieveResponses[keyof UserOnchainTransactionsRetrieveResponses];
+type UserOnchainTransactionsPartialUpdateData = {
+    body?: PatchedOnchainTransactionWritable;
+    path: {
+        identifier: string;
+    };
+    query?: never;
+    url: '/user/onchain-transactions/{identifier}/';
+};
+type UserOnchainTransactionsPartialUpdateResponses = {
+    200: OnchainTransactionResponse;
+};
+type UserOnchainTransactionsPartialUpdateResponse = UserOnchainTransactionsPartialUpdateResponses[keyof UserOnchainTransactionsPartialUpdateResponses];
+type UserOnchainTransactionsUpdateData = {
+    body: OnchainTransactionWritable;
+    path: {
+        identifier: string;
+    };
+    query?: never;
+    url: '/user/onchain-transactions/{identifier}/';
+};
+type UserOnchainTransactionsUpdateResponses = {
+    200: OnchainTransactionResponse;
+};
+type UserOnchainTransactionsUpdateResponse = UserOnchainTransactionsUpdateResponses[keyof UserOnchainTransactionsUpdateResponses];
+type UserOnchainTransactionsCancelCreateData = {
+    body?: ActionResponse;
+    path: {
+        identifier: string;
+    };
+    query?: never;
+    url: '/user/onchain-transactions/{identifier}/cancel/';
+};
+type UserOnchainTransactionsCancelCreateResponses = {
+    200: OnchainTransactionResponse;
+};
+type UserOnchainTransactionsCancelCreateResponse = UserOnchainTransactionsCancelCreateResponses[keyof UserOnchainTransactionsCancelCreateResponses];
+type WebhookCreateData = {
+    body: Webhook;
+    path?: never;
+    query?: never;
+    url: '/webhook/';
+};
+type WebhookCreateResponses = {
+    200: ActionResponse;
+};
+type WebhookCreateResponse = WebhookCreateResponses[keyof WebhookCreateResponses];
+
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options$1<TData, ThrowOnError> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+declare const activateCreate: <ThrowOnError extends boolean = false>(options: Options<ActivateCreateData, ThrowOnError>) => RequestResult<ActivateCreateResponses, unknown, ThrowOnError, "data">;
+declare const adminAddressesList: <ThrowOnError extends boolean = false>(options?: Options<AdminAddressesListData, ThrowOnError>) => RequestResult<AdminAddressesListResponses, unknown, ThrowOnError, "data">;
+declare const adminAddressesRetrieve: <ThrowOnError extends boolean = false>(options: Options<AdminAddressesRetrieveData, ThrowOnError>) => RequestResult<AdminAddressesRetrieveResponses, unknown, ThrowOnError, "data">;
+declare const adminCompanyRetrieve: <ThrowOnError extends boolean = false>(options?: Options<AdminCompanyRetrieveData, ThrowOnError>) => RequestResult<AdminCompanyRetrieveResponses, unknown, ThrowOnError, "data">;
+declare const adminCompanyPartialUpdate: <ThrowOnError extends boolean = false>(options?: Options<AdminCompanyPartialUpdateData, ThrowOnError>) => RequestResult<AdminCompanyPartialUpdateResponses, unknown, ThrowOnError, "data">;
+declare const adminCompanyUpdate: <ThrowOnError extends boolean = false>(options?: Options<AdminCompanyUpdateData, ThrowOnError>) => RequestResult<AdminCompanyUpdateResponses, unknown, ThrowOnError, "data">;
+declare const adminOnchainTransactionsList: <ThrowOnError extends boolean = false>(options?: Options<AdminOnchainTransactionsListData, ThrowOnError>) => RequestResult<AdminOnchainTransactionsListResponses, unknown, ThrowOnError, "data">;
+declare const adminOnchainTransactionsRetrieve: <ThrowOnError extends boolean = false>(options: Options<AdminOnchainTransactionsRetrieveData, ThrowOnError>) => RequestResult<AdminOnchainTransactionsRetrieveResponses, unknown, ThrowOnError, "data">;
+declare const alchemyWebhookCreate: <ThrowOnError extends boolean = false>(options: Options<AlchemyWebhookCreateData, ThrowOnError>) => RequestResult<AlchemyWebhookCreateResponses, unknown, ThrowOnError, "data">;
+declare const deactivateCreate: <ThrowOnError extends boolean = false>(options: Options<DeactivateCreateData, ThrowOnError>) => RequestResult<DeactivateCreateResponses, unknown, ThrowOnError, "data">;
+declare const userAccountAddressLookupCreate: <ThrowOnError extends boolean = false>(options: Options<UserAccountAddressLookupCreateData, ThrowOnError>) => RequestResult<UserAccountAddressLookupCreateResponses, unknown, ThrowOnError, "data">;
+declare const userAddressesList: <ThrowOnError extends boolean = false>(options?: Options<UserAddressesListData, ThrowOnError>) => RequestResult<UserAddressesListResponses, unknown, ThrowOnError, "data">;
+declare const userAddressesCreate: <ThrowOnError extends boolean = false>(options: Options<UserAddressesCreateData, ThrowOnError>) => RequestResult<UserAddressesCreateResponses, unknown, ThrowOnError, "data">;
+declare const userAddressesRetrieve: <ThrowOnError extends boolean = false>(options: Options<UserAddressesRetrieveData, ThrowOnError>) => RequestResult<UserAddressesRetrieveResponses, unknown, ThrowOnError, "data">;
+declare const userOnchainTransactionsList: <ThrowOnError extends boolean = false>(options?: Options<UserOnchainTransactionsListData, ThrowOnError>) => RequestResult<UserOnchainTransactionsListResponses, unknown, ThrowOnError, "data">;
+declare const userOnchainTransactionsRetrieve: <ThrowOnError extends boolean = false>(options: Options<UserOnchainTransactionsRetrieveData, ThrowOnError>) => RequestResult<UserOnchainTransactionsRetrieveResponses, unknown, ThrowOnError, "data">;
+declare const userOnchainTransactionsPartialUpdate: <ThrowOnError extends boolean = false>(options: Options<UserOnchainTransactionsPartialUpdateData, ThrowOnError>) => RequestResult<UserOnchainTransactionsPartialUpdateResponses, unknown, ThrowOnError, "data">;
+declare const userOnchainTransactionsUpdate: <ThrowOnError extends boolean = false>(options: Options<UserOnchainTransactionsUpdateData, ThrowOnError>) => RequestResult<UserOnchainTransactionsUpdateResponses, unknown, ThrowOnError, "data">;
+declare const userOnchainTransactionsCancelCreate: <ThrowOnError extends boolean = false>(options: Options<UserOnchainTransactionsCancelCreateData, ThrowOnError>) => RequestResult<UserOnchainTransactionsCancelCreateResponses, unknown, ThrowOnError, "data">;
+declare const webhookCreate: <ThrowOnError extends boolean = false>(options: Options<WebhookCreateData, ThrowOnError>) => RequestResult<WebhookCreateResponses, unknown, ThrowOnError, "data">;
+
+type sdk_Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options<TData, ThrowOnError>;
+declare const sdk_activateCreate: typeof activateCreate;
+declare const sdk_adminAddressesList: typeof adminAddressesList;
+declare const sdk_adminAddressesRetrieve: typeof adminAddressesRetrieve;
+declare const sdk_adminCompanyPartialUpdate: typeof adminCompanyPartialUpdate;
+declare const sdk_adminCompanyRetrieve: typeof adminCompanyRetrieve;
+declare const sdk_adminCompanyUpdate: typeof adminCompanyUpdate;
+declare const sdk_adminOnchainTransactionsList: typeof adminOnchainTransactionsList;
+declare const sdk_adminOnchainTransactionsRetrieve: typeof adminOnchainTransactionsRetrieve;
+declare const sdk_alchemyWebhookCreate: typeof alchemyWebhookCreate;
+declare const sdk_deactivateCreate: typeof deactivateCreate;
+declare const sdk_userAccountAddressLookupCreate: typeof userAccountAddressLookupCreate;
+declare const sdk_userAddressesCreate: typeof userAddressesCreate;
+declare const sdk_userAddressesList: typeof userAddressesList;
+declare const sdk_userAddressesRetrieve: typeof userAddressesRetrieve;
+declare const sdk_userOnchainTransactionsCancelCreate: typeof userOnchainTransactionsCancelCreate;
+declare const sdk_userOnchainTransactionsList: typeof userOnchainTransactionsList;
+declare const sdk_userOnchainTransactionsPartialUpdate: typeof userOnchainTransactionsPartialUpdate;
+declare const sdk_userOnchainTransactionsRetrieve: typeof userOnchainTransactionsRetrieve;
+declare const sdk_userOnchainTransactionsUpdate: typeof userOnchainTransactionsUpdate;
+declare const sdk_webhookCreate: typeof webhookCreate;
+declare namespace sdk {
+  export { type sdk_Options as Options, sdk_activateCreate as activateCreate, sdk_adminAddressesList as adminAddressesList, sdk_adminAddressesRetrieve as adminAddressesRetrieve, sdk_adminCompanyPartialUpdate as adminCompanyPartialUpdate, sdk_adminCompanyRetrieve as adminCompanyRetrieve, sdk_adminCompanyUpdate as adminCompanyUpdate, sdk_adminOnchainTransactionsList as adminOnchainTransactionsList, sdk_adminOnchainTransactionsRetrieve as adminOnchainTransactionsRetrieve, sdk_alchemyWebhookCreate as alchemyWebhookCreate, sdk_deactivateCreate as deactivateCreate, sdk_userAccountAddressLookupCreate as userAccountAddressLookupCreate, sdk_userAddressesCreate as userAddressesCreate, sdk_userAddressesList as userAddressesList, sdk_userAddressesRetrieve as userAddressesRetrieve, sdk_userOnchainTransactionsCancelCreate as userOnchainTransactionsCancelCreate, sdk_userOnchainTransactionsList as userOnchainTransactionsList, sdk_userOnchainTransactionsPartialUpdate as userOnchainTransactionsPartialUpdate, sdk_userOnchainTransactionsRetrieve as userOnchainTransactionsRetrieve, sdk_userOnchainTransactionsUpdate as userOnchainTransactionsUpdate, sdk_webhookCreate as webhookCreate };
+}
+
+type AlchemyApi = BoundSdk<typeof sdk>;
+declare function createAlchemyApi(config: ApiFactoryConfig): AlchemyApi;
+
+export { type AccountAddressLookup, type AccountAddressLookupResponse, type ActionResponse, type Activate, type ActivateCreateData, type ActivateCreateResponse, type ActivateCreateResponses, type Address, type AddressResponse, type AddressResponseWritable, type AddressWritable, type AdminAddress, type AdminAddressResponse, type AdminAddressResponseWritable, type AdminAddressWritable, type AdminAddressesListData, type AdminAddressesListResponse, type AdminAddressesListResponses, type AdminAddressesRetrieveData, type AdminAddressesRetrieveResponse, type AdminAddressesRetrieveResponses, type AdminCompany, type AdminCompanyPartialUpdateData, type AdminCompanyPartialUpdateResponse, type AdminCompanyPartialUpdateResponses, type AdminCompanyResponse, type AdminCompanyResponseWritable, type AdminCompanyRetrieveData, type AdminCompanyRetrieveResponse, type AdminCompanyRetrieveResponses, type AdminCompanyUpdateData, type AdminCompanyUpdateResponse, type AdminCompanyUpdateResponses, type AdminCompanyWritable, type AdminOnchainTransaction, type AdminOnchainTransactionResponse, type AdminOnchainTransactionResponseWritable, type AdminOnchainTransactionWritable, type AdminOnchainTransactionsListData, type AdminOnchainTransactionsListResponse, type AdminOnchainTransactionsListResponses, type AdminOnchainTransactionsRetrieveData, type AdminOnchainTransactionsRetrieveResponse, type AdminOnchainTransactionsRetrieveResponses, type AlchemyApi, type AlchemyWebhook, type AlchemyWebhookCreateData, type AlchemyWebhookCreateResponse, type AlchemyWebhookCreateResponses, type ClientOptions, type Currency, type Deactivate, type DeactivateCreateData, type DeactivateCreateResponse, type DeactivateCreateResponses, type OnchainTransaction, type OnchainTransactionResponse, type OnchainTransactionResponseWritable, type OnchainTransactionWritable, type PaginatedAddressList, type PaginatedAddressListResponse, type PaginatedAddressListResponseWritable, type PaginatedAddressListWritable, type PaginatedAdminAddressList, type PaginatedAdminAddressListResponse, type PaginatedAdminAddressListResponseWritable, type PaginatedAdminAddressListWritable, type PaginatedAdminOnchainTransactionList, type PaginatedAdminOnchainTransactionListResponse, type PaginatedAdminOnchainTransactionListResponseWritable, type PaginatedAdminOnchainTransactionListWritable, type PaginatedOnchainTransactionList, type PaginatedOnchainTransactionListResponse, type PaginatedOnchainTransactionListResponseWritable, type PaginatedOnchainTransactionListWritable, type PatchedAdminCompany, type PatchedAdminCompanyWritable, type PatchedOnchainTransaction, type PatchedOnchainTransactionWritable, type User, type UserAccountAddressLookupCreateData, type UserAccountAddressLookupCreateResponse, type UserAccountAddressLookupCreateResponses, type UserAddressesCreateData, type UserAddressesCreateResponse, type UserAddressesCreateResponses, type UserAddressesListData, type UserAddressesListResponse, type UserAddressesListResponses, type UserAddressesRetrieveData, type UserAddressesRetrieveResponse, type UserAddressesRetrieveResponses, type UserOnchainTransactionsCancelCreateData, type UserOnchainTransactionsCancelCreateResponse, type UserOnchainTransactionsCancelCreateResponses, type UserOnchainTransactionsListData, type UserOnchainTransactionsListResponse, type UserOnchainTransactionsListResponses, type UserOnchainTransactionsPartialUpdateData, type UserOnchainTransactionsPartialUpdateResponse, type UserOnchainTransactionsPartialUpdateResponses, type UserOnchainTransactionsRetrieveData, type UserOnchainTransactionsRetrieveResponse, type UserOnchainTransactionsRetrieveResponses, type UserOnchainTransactionsUpdateData, type UserOnchainTransactionsUpdateResponse, type UserOnchainTransactionsUpdateResponses, type Webhook, type WebhookCreateData, type WebhookCreateResponse, type WebhookCreateResponses, createAlchemyApi };