summaryrefslogtreecommitdiff
path: root/frontend-old/node_modules/@grpc/grpc-js/build/src/client-interceptors.d.ts
diff options
context:
space:
mode:
authoraltaf-creator <dev@altafcreator.com>2025-11-09 11:15:19 +0800
committeraltaf-creator <dev@altafcreator.com>2025-11-09 11:15:19 +0800
commit8eff962cab608341a6f2fedc640a0e32d96f26e2 (patch)
tree05534d1a720ddc3691d346c69b4972555820a061 /frontend-old/node_modules/@grpc/grpc-js/build/src/client-interceptors.d.ts
pain
Diffstat (limited to 'frontend-old/node_modules/@grpc/grpc-js/build/src/client-interceptors.d.ts')
-rw-r--r--frontend-old/node_modules/@grpc/grpc-js/build/src/client-interceptors.d.ts120
1 files changed, 120 insertions, 0 deletions
diff --git a/frontend-old/node_modules/@grpc/grpc-js/build/src/client-interceptors.d.ts b/frontend-old/node_modules/@grpc/grpc-js/build/src/client-interceptors.d.ts
new file mode 100644
index 0000000..1ecfb34
--- /dev/null
+++ b/frontend-old/node_modules/@grpc/grpc-js/build/src/client-interceptors.d.ts
@@ -0,0 +1,120 @@
+import { Metadata } from './metadata';
+import { Listener, MetadataListener, MessageListener, StatusListener, InterceptingListener, MessageContext } from './call-interface';
+import { Status } from './constants';
+import { Channel } from './channel';
+import { CallOptions } from './client';
+import { ClientMethodDefinition } from './make-client';
+/**
+ * Error class associated with passing both interceptors and interceptor
+ * providers to a client constructor or as call options.
+ */
+export declare class InterceptorConfigurationError extends Error {
+ constructor(message: string);
+}
+export interface MetadataRequester {
+ (metadata: Metadata, listener: InterceptingListener, next: (metadata: Metadata, listener: InterceptingListener | Listener) => void): void;
+}
+export interface MessageRequester {
+ (message: any, next: (message: any) => void): void;
+}
+export interface CloseRequester {
+ (next: () => void): void;
+}
+export interface CancelRequester {
+ (next: () => void): void;
+}
+/**
+ * An object with methods for intercepting and modifying outgoing call operations.
+ */
+export interface FullRequester {
+ start: MetadataRequester;
+ sendMessage: MessageRequester;
+ halfClose: CloseRequester;
+ cancel: CancelRequester;
+}
+export type Requester = Partial<FullRequester>;
+export declare class ListenerBuilder {
+ private metadata;
+ private message;
+ private status;
+ withOnReceiveMetadata(onReceiveMetadata: MetadataListener): this;
+ withOnReceiveMessage(onReceiveMessage: MessageListener): this;
+ withOnReceiveStatus(onReceiveStatus: StatusListener): this;
+ build(): Listener;
+}
+export declare class RequesterBuilder {
+ private start;
+ private message;
+ private halfClose;
+ private cancel;
+ withStart(start: MetadataRequester): this;
+ withSendMessage(sendMessage: MessageRequester): this;
+ withHalfClose(halfClose: CloseRequester): this;
+ withCancel(cancel: CancelRequester): this;
+ build(): Requester;
+}
+export interface InterceptorOptions extends CallOptions {
+ method_definition: ClientMethodDefinition<any, any>;
+}
+export interface InterceptingCallInterface {
+ cancelWithStatus(status: Status, details: string): void;
+ getPeer(): string;
+ start(metadata: Metadata, listener?: Partial<InterceptingListener>): void;
+ sendMessageWithContext(context: MessageContext, message: any): void;
+ sendMessage(message: any): void;
+ startRead(): void;
+ halfClose(): void;
+}
+export declare class InterceptingCall implements InterceptingCallInterface {
+ private nextCall;
+ /**
+ * The requester that this InterceptingCall uses to modify outgoing operations
+ */
+ private requester;
+ /**
+ * Indicates that metadata has been passed to the requester's start
+ * method but it has not been passed to the corresponding next callback
+ */
+ private processingMetadata;
+ /**
+ * Message context for a pending message that is waiting for
+ */
+ private pendingMessageContext;
+ private pendingMessage;
+ /**
+ * Indicates that a message has been passed to the requester's sendMessage
+ * method but it has not been passed to the corresponding next callback
+ */
+ private processingMessage;
+ /**
+ * Indicates that a status was received but could not be propagated because
+ * a message was still being processed.
+ */
+ private pendingHalfClose;
+ constructor(nextCall: InterceptingCallInterface, requester?: Requester);
+ cancelWithStatus(status: Status, details: string): void;
+ getPeer(): string;
+ private processPendingMessage;
+ private processPendingHalfClose;
+ start(metadata: Metadata, interceptingListener?: Partial<InterceptingListener>): void;
+ sendMessageWithContext(context: MessageContext, message: any): void;
+ sendMessage(message: any): void;
+ startRead(): void;
+ halfClose(): void;
+}
+export interface NextCall {
+ (options: InterceptorOptions): InterceptingCallInterface;
+}
+export interface Interceptor {
+ (options: InterceptorOptions, nextCall: NextCall): InterceptingCall;
+}
+export interface InterceptorProvider {
+ (methodDefinition: ClientMethodDefinition<any, any>): Interceptor;
+}
+export interface InterceptorArguments {
+ clientInterceptors: Interceptor[];
+ clientInterceptorProviders: InterceptorProvider[];
+ callInterceptors: Interceptor[];
+ callInterceptorProviders: InterceptorProvider[];
+}
+export declare function getInterceptingCall(interceptorArgs: InterceptorArguments, methodDefinition: ClientMethodDefinition<any, any>, options: CallOptions, channel: Channel): InterceptingCallInterface;