Client class

new Client(transport: DeviceTransport, connStr?: string, blobUploadClient?: BlobUploadClient, fileUploadApi?: FileUploadInterface)

Parâmetros

Valor: booliano

Altere a opção de captureRejections padrão em todos os novos objetos EventEmitter.

static captureRejections: boolean

Valor da propriedade

herdado de InternalClient.captureRejections

Valor: Symbol.for('nodejs.rejection')

Veja como escrever um rejection handlerpersonalizado.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valor da propriedade

Herdado de InternalClient.captureRejectionSymbol

Por padrão, no máximo 10 ouvintes podem ser registrados para qualquer evento único. Esse limite pode ser alterado para instâncias de EventEmitter individuais usando o método emitter.setMaxListeners(n). Para alterar o padrão para todas as instânciasEventEmitter, a propriedade events.defaultMaxListeners pode ser usada. Se esse valor não for um número positivo, um RangeError será gerado.

Tome cuidado ao definir o events.defaultMaxListeners porque a alteração afeta todas as instânciasEventEmitter, incluindo aquelas criadas antes da alteração ser feita. No entanto, chamar emitter.setMaxListeners(n) ainda tem precedência sobre events.defaultMaxListeners.

Este não é um limite difícil. A instância de EventEmitter permitirá que mais ouvintes sejam adicionados, mas gerará um aviso de rastreamento para stderr indicando que um "possível vazamento de memória eventEmitter" foi detectado. Para qualquer EventEmitterindividual, os métodos emitter.getMaxListeners() e emitter.setMaxListeners() podem ser usados para evitar temporariamente este aviso:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

O sinalizador de linha de comando --trace-warnings pode ser usado para exibir o rastreamento de pilha para esses avisos.

O aviso emitido pode ser inspecionado com process.on('warning') e terá as propriedades emitter, typee count adicionais, referindo-se à instância do emissor do evento, ao nome do evento e ao número de ouvintes anexados, respectivamente. Sua propriedade name está definida como 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valor da propriedade

herdado de InternalClient.defaultMaxListeners

Esse símbolo deve ser usado para instalar um ouvinte apenas para monitorar eventos 'error'. Os ouvintes instalados usando esse símbolo são chamados antes que os ouvintes de 'error' regulares sejam chamados.

Instalar um ouvinte usando esse símbolo não altera o comportamento depois que um evento 'error' é emitido. Portanto, o processo ainda falhará se nenhum ouvinte de 'error' regular estiver instalado.

static errorMonitor: typeof errorMonitor

Valor da propriedade

herdado de InternalClient.errorMonitor

function close(): Promise<Disconnected>

Retornos

Fecha a conexão de transporte e destrói os recursos do cliente.

Observação: depois de chamar esse método, o objeto Cliente não pode ser reutilizado.

function close(closeCallback?: Callback<Disconnected>)

Parâmetros

Cria um cliente de dispositivo do Hub IoT com base no método de autenticação fornecido e usando o tipo de transporte fornecido.

static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): Client

Parâmetros

Retornos

Cria um cliente de dispositivo do Hub IoT da cadeia de conexão fornecida usando o tipo de transporte fornecido.

static function fromConnectionString(connStr: string, transportCtor: any): Client

Parâmetros

Retornos

Cria um cliente de dispositivo do Hub IoT com base na assinatura de acesso compartilhado fornecida usando o tipo de transporte fornecido.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): Client

Parâmetros

Retornos

function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>

Parâmetros

Retornos

O getBlobSharedAccessSignature obtém o token SAS da conta de armazenamento vinculada do Hub IoT

function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)

Parâmetros

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string): Promise<void>

Parâmetros

Retornos

O método notifyBlobUploadStatus envia ao Hub IoT o resultado de um upload de blob.

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)

Parâmetros

Registra um retorno de chamada para um método chamado methodName.

function onDeviceMethod(methodName: string, callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Parâmetros

function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>

Parâmetros

Retornos

function setOptions(options: DeviceClientOptions, done: Callback<TransportConfigured>)

Parâmetros

function uploadToBlob(blobName: string, stream: Stream, streamLength: number): Promise<void>

Parâmetros

Retornos

O método uploadToBlob carrega um fluxo para um blob.

function uploadToBlob(blobName: string, stream: Stream, streamLength: number, callback: ErrorCallback)

Parâmetros

function abandon(message: Message): Promise<MessageAbandoned>

Parâmetros

Retornos

herdado de InternalClient.abandon

function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)

Parâmetros

herdado de InternalClient.abandon

Escuta uma vez o evento abort no signalfornecido.

Ouvir o evento abort em sinais de anulação não é seguro e pode levar a vazamentos de recursos, já que outro terceiro com o sinal pode chamar e.stopImmediatePropagation(). Infelizmente Node.js não pode alterar isso, pois isso violaria o padrão da Web. Além disso, a API original facilita a remoção dos ouvintes.

Essa API permite usar com segurança AbortSignals em APIs Node.js resolvendo esses dois problemas ouvindo o evento de modo que stopImmediatePropagation não impeça a execução do ouvinte.

Retorna um descartável para que ele possa ser desconscrito com mais facilidade.

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}

static function addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable

Parâmetros

Retornos

Descartável que remove o ouvinte abort.

Herdado de InternalClient.addAbortListener

Alias para emitter.on(eventName, listener).

function addListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parâmetros

Retornos

Herdado de InternalClient.addListener

function complete(message: Message): Promise<MessageCompleted>

Parâmetros

Retornos

Herdado de InternalClient.complete

function complete(message: Message, completeCallback: Callback<MessageCompleted>)

Parâmetros

Herdado de InternalClient.complete

Chama de forma síncrona cada um dos ouvintes registrados para o evento chamado eventName, na ordem em que foram registrados, passando os argumentos fornecidos para cada um.

Retorna true se o evento tiver ouvintes, false caso contrário.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

function emit<K>(eventName: string | symbol, args: AnyRest): boolean

Parâmetros

Retornos

Herdado de InternalClient.emit

Retorna uma matriz listando os eventos para os quais o emissor registrou ouvintes. Os valores na matriz são cadeias de caracteres ou Symbols.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

Retornos

Herdado de InternalClient.eventNames

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName.

Por EventEmitterisso se comporta exatamente da mesma forma que chamar .listeners no emissor.

Para EventTargetesta é a única maneira de obter os ouvintes de eventos para o destino do evento. Isso é útil para fins de depuração e diagnóstico.

import { getEventListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget, name: string | symbol): Function[]

Parâmetros

Retornos

herdado de InternalClient.getEventListeners

Retorna o valor máximo atual do ouvinte para o EventEmitter que é definido por emitter.setMaxListeners(n) ou padrões para defaultMaxListeners.

function getMaxListeners(): number

Retornos

herdado de InternalClient.getMaxListeners

Retorna a quantidade máxima de ouvintes definida no momento.

Por EventEmitterisso se comporta exatamente da mesma forma que chamar .getMaxListeners no emissor.

Para EventTargetesta é a única maneira de obter o máximo de ouvintes de eventos para o destino do evento. Se o número de manipuladores de eventos em um único EventTarget exceder o conjunto máximo, o EventTarget imprimirá um aviso.

import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}

static function getMaxListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget): number

Parâmetros

Retornos

herdado de InternalClient.getMaxListeners

function getTwin(): Promise<Twin>

Retornos

herdado de InternalClient.getTwin

function getTwin(done: Callback<Twin>)

Parâmetros

herdado de InternalClient.getTwin

Um método de classe que retorna o número de ouvintes para o determinado eventName registrado no emitterdeterminado.

import { EventEmitter, listenerCount } from 'node:events';

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

static function listenerCount(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol): number

Parâmetros

Retornos

Herdado de InternalClient.listenerCount

Retorna o número de ouvintes que escutam o evento chamado eventName. Se listener for fornecido, ele retornará quantas vezes o ouvinte é encontrado na lista de ouvintes do evento.

function listenerCount<K>(eventName: string | symbol, listener?: Function): number

Parâmetros

Retornos

Herdado de InternalClient.listenerCount

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

function listeners<K>(eventName: string | symbol): Function[]

Parâmetros

Retornos

Herdado de InternalClient.listeners

Alias para emitter.removeListener().

function off<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parâmetros

Retornos

Herdado de InternalClient.off

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Retorna um AsyncIterator que itera eventos eventName. Ele será lançado se o EventEmitter emitir 'error'. Ele remove todos os ouvintes ao sair do loop. O value retornado por cada iteração é uma matriz composta pelos argumentos de evento emitidos.

Um AbortSignal pode ser usado para cancelar a espera de eventos:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

Use a opção close para especificar uma matriz de nomes de eventos que encerrará a iteração:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parâmetros

Retornos

Um AsyncIterator que itera eventos eventName emitidos pelo emitter

Herdado de InternalClient.on

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parâmetros

Retornos

Herdado de InternalClient.on

Adiciona a função listener ao final da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

server.on('connection', (stream) => {
  console.log('someone connected!');
});

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function on<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parâmetros

Retornos

Herdado de InternalClient.on

Cria um Promise que é atendido quando o EventEmitter emite o evento determinado ou que é rejeitado se o EventEmitter emite 'error' enquanto aguarda. O Promise será resolvido com uma matriz de todos os argumentos emitidos para o evento fornecido.

Esse método é intencionalmente genérico e funciona com a plataforma Web interface EventTarget, que não tem nenhuma semântica de evento'error' especial e não escuta o evento 'error'.

import { once, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

O tratamento especial do evento 'error' só é usado quando events.once() é usado para aguardar outro evento. Se events.once() for usado para aguardar o evento 'error' em si, ele será tratado como qualquer outro tipo de evento sem tratamento especial:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

Um AbortSignal pode ser usado para cancelar a espera do evento:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

static function once(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>

Parâmetros

Retornos

herdado de InternalClient.once

static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>

Parâmetros

Retornos

herdado de InternalClient.once

Adiciona uma função de única para o evento chamado . Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependOnceListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function once<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parâmetros

Retornos

herdado de InternalClient.once

function open(): Promise<Connected>

Retornos

herdado de InternalClient.open

function open(openCallback: Callback<Connected>)

Parâmetros

herdado de InternalClient.open

Adiciona a função listener à inicial da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function prependListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parâmetros

Retornos

Herdado de InternalClient.prependListener

Adiciona uma função de única para o evento chamado à inicial da matriz de ouvintes. Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function prependOnceListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parâmetros

Retornos

Herdado de InternalClient.prependOnceListener

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName, incluindo quaisquer wrappers (como aqueles criados por .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

function rawListeners<K>(eventName: string | symbol): Function[]

Parâmetros

Retornos

herdado de InternalClient.rawListeners

function reject(message: Message): Promise<MessageRejected>

Parâmetros

Retornos

herdado de InternalClient.reject

function reject(message: Message, rejectCallback: Callback<MessageRejected>)

Parâmetros

herdado de InternalClient.reject

Remove todos os ouvintes ou os do eventNameespecificado.

É uma má prática remover ouvintes adicionados em outro lugar no código, especialmente quando a instância de EventEmitter foi criada por algum outro componente ou módulo (por exemplo, soquetes ou fluxos de arquivo).

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function removeAllListeners(eventName?: string | symbol): Client

Parâmetros

Retornos

herdado de InternalClient.removeAllListeners

Remove o listener especificado da matriz de ouvintes para o evento chamado eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

removeListener() removerá, no máximo, uma instância de um ouvinte da matriz do ouvinte. Se qualquer ouvinte tiver sido adicionado várias vezes à matriz de ouvintes para o eventNameespecificado, removeListener() deverá ser chamado várias vezes para remover cada instância.

Depois que um evento é emitido, todos os ouvintes anexados a ele no momento da emissão são chamados em ordem. Isso implica que qualquer removeListener() ou removeAllListeners() chamadas após emitindo e antes de o último ouvinte concluir a execução não os removerá deemit() em andamento. Os eventos subsequentes se comportam conforme o esperado.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

Como os ouvintes são gerenciados usando uma matriz interna, chamar isso alterará os índices de posição de qualquer ouvinte registrado após o ouvinte ser removido. Isso não afetará a ordem na qual os ouvintes são chamados, mas significa que todas as cópias da matriz do ouvinte, conforme retornado pelo método emitter.listeners(), precisarão ser recriadas.

Quando uma única função tiver sido adicionada como um manipulador várias vezes para um único evento (como no exemplo abaixo), removeListener() removerá a instância adicionada mais recentemente. No exemplo, o ouvinte once('ping') é removido:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parâmetros

Retornos

herdado de InternalClient.removeListener

function sendEvent(message: Message): Promise<MessageEnqueued>

Parâmetros

Retornos

herdado de InternalClient.sendEvent

function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)

Parâmetros

herdado de InternalClient.sendEvent

function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>

Parâmetros

Retornos

herdado de InternalClient.sendEventBatch

function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)

Parâmetros

herdado de InternalClient.sendEventBatch

Por padrão, EventEmitterimprimirão um aviso se mais de 10 ouvintes forem adicionados para um evento específico. Esse é um padrão útil que ajuda a localizar vazamentos de memória. O método emitter.setMaxListeners() permite que o limite seja modificado para esta instância de EventEmitter específica. O valor pode ser definido como Infinity (ou 0) para indicar um número ilimitado de ouvintes.

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function setMaxListeners(n: number): Client

Parâmetros

Retornos

herdado de InternalClient.setMaxListeners

import { setMaxListeners, EventEmitter } from 'node:events';

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);

static function setMaxListeners(n?: number, eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[])

Parâmetros

herdado de InternalClient.setMaxListeners

Define a política de repetição usada pelo cliente em todas as operações. O padrão é ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parâmetros

herdado de InternalClient.setRetryPolicy

function setTransportOptions(options: any): Promise<TransportConfigured>

Parâmetros

Retornos

Herdado de InternalClient.setTransportOptions

function setTransportOptions(options: any, done: Callback<TransportConfigured>)

Parâmetros

Herdado de InternalClient.setTransportOptions

function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)

Parâmetros

herdado de InternalClient.updateSharedAccessSignature

function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)

Parâmetros

herdado de InternalClient.__@captureRejectionSymbol@141