@openfeature/flagd-provider 0.7.6 → 0.8.0

package/src/proto/ts/sync/v1/sync_service.d.ts

@@ -1,183 +1,206 @@
-import { ServiceType } from "@protobuf-ts/runtime-rpc";
-import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from "@protobuf-ts/runtime";
-import type { PartialMessage } from "@protobuf-ts/runtime";
-import { MessageType } from "@protobuf-ts/runtime";
-/**
- * SyncFlagsRequest is the request initiating the sever-streaming rpc. Flagd sends this request, acting as the client
- *
- * @generated from protobuf message sync.v1.SyncFlagsRequest
- */
-export interface SyncFlagsRequest {
-    /**
-     * Optional: A unique identifier for flagd(grpc client) initiating the request. The server implementations may
-     * utilize this identifier to uniquely identify, validate(ex:- enforce authentication/authorization) and filter
-     * flag configurations that it can expose to this request. This field is intended to be optional. However server
-     * implementations may enforce it.
-     *    ex:- provider_id: flagd-weatherapp-sidecar
-     *
-     * @generated from protobuf field: string provider_id = 1;
-     */
-    providerId: string;
-    /**
-     * Optional: A selector for the flag configuration request. The server implementation may utilize this to select
-     * flag configurations from a collection, select the source of the flag or combine this to any desired underlying
-     * filtering mechanism.
-     *    ex:- selector: 'source=database,app=weatherapp'
-     *
-     * @generated from protobuf field: string selector = 2;
-     */
-    selector: string;
-}
-/**
- * SyncFlagsResponse is the server response containing feature flag configurations and the state
- *
- * @generated from protobuf message sync.v1.SyncFlagsResponse
- */
-export interface SyncFlagsResponse {
-    /**
-     * flagd feature flag configuration. Must be validated to schema - https://raw.githubusercontent.com/open-feature/schemas/main/json/flagd-definitions.json
-     *
-     * @generated from protobuf field: string flag_configuration = 1;
-     */
-    flagConfiguration: string;
-    /**
-     * State conveying the operation to be performed by flagd. See the descriptions of SyncState for an explanation of
-     * supported values
-     *
-     * @generated from protobuf field: sync.v1.SyncState state = 2;
-     */
-    state: SyncState;
-}
-/**
- * FetchAllFlagsRequest is the request to fetch all flags. Flagd sends this request as the client in order to resync its internal state
- *
- * @generated from protobuf message sync.v1.FetchAllFlagsRequest
- */
-export interface FetchAllFlagsRequest {
-    /**
-     * Optional: A unique identifier for flagd(grpc client) initiating the request. The server implementations may
-     * utilize this identifier to uniquely identify, validate(ex:- enforce authentication/authorization) and filter
-     * flag configurations that it can expose to this request. This field is intended to be optional. However server
-     * implementations may enforce it.
-     *    ex:- provider_id: flagd-weatherapp-sidecar
-     *
-     * @generated from protobuf field: string provider_id = 1;
-     */
-    providerId: string;
-    /**
-     * Optional: A selector for the flag configuration request. The server implementation may utilize this to select
-     * flag configurations from a collection, select the source of the flag or combine this to any desired underlying
-     * filtering mechanism.
-     *    ex:- selector: 'source=database,app=weatherapp'
-     *
-     * @generated from protobuf field: string selector = 2;
-     */
-    selector: string;
-}
-/**
- *  FetchAllFlagsResponse is the server response containing feature flag configurations
- *
- * @generated from protobuf message sync.v1.FetchAllFlagsResponse
- */
-export interface FetchAllFlagsResponse {
-    /**
-     * flagd feature flag configuration. Must be validated to schema - https://raw.githubusercontent.com/open-feature/schemas/main/json/flagd-definitions.json
-     *
-     * @generated from protobuf field: string flag_configuration = 1;
-     */
-    flagConfiguration: string;
-}
-/**
- * SyncState conveys the state of the payload. These states are related to flagd isync.go type definitions but
- * contains extras to optimize grpc use case. Refer - https://github.com/open-feature/flagd/blob/main/pkg/sync/isync.go
- *
- * @generated from protobuf enum sync.v1.SyncState
- */
-export declare enum SyncState {
-    /**
-     * Value is ignored by the listening flagd
-     *
-     * @generated from protobuf enum value: SYNC_STATE_UNSPECIFIED = 0;
-     */
-    UNSPECIFIED = 0,
-    /**
-     * All the flags matching the request. This is the default response and other states can be ignored
-     * by the implementation. Flagd internally replaces all existing flags for this response state.
-     *
-     * @generated from protobuf enum value: SYNC_STATE_ALL = 1;
-     */
-    ALL = 1,
-    /**
-     * Convey an addition of a flag. Flagd internally handles this by combining new flags with existing ones
-     *
-     * @generated from protobuf enum value: SYNC_STATE_ADD = 2;
-     */
-    ADD = 2,
-    /**
-     * Convey an update of a flag. Flagd internally attempts to update if the updated flag already exist OR if it does not,
-     * it will get added
-     *
-     * @generated from protobuf enum value: SYNC_STATE_UPDATE = 3;
-     */
-    UPDATE = 3,
-    /**
-     * Convey a deletion of a flag. Flagd internally removes the flag
-     *
-     * @generated from protobuf enum value: SYNC_STATE_DELETE = 4;
-     */
-    DELETE = 4,
-    /**
-     * Optional server ping to check client connectivity. Handling is ignored by flagd and is to merely support live check
-     *
-     * @generated from protobuf enum value: SYNC_STATE_PING = 5;
-     */
-    PING = 5
-}
-declare class SyncFlagsRequest$Type extends MessageType<SyncFlagsRequest> {
-    constructor();
-    create(value?: PartialMessage<SyncFlagsRequest>): SyncFlagsRequest;
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SyncFlagsRequest): SyncFlagsRequest;
-    internalBinaryWrite(message: SyncFlagsRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-/**
- * @generated MessageType for protobuf message sync.v1.SyncFlagsRequest
- */
-export declare const SyncFlagsRequest: SyncFlagsRequest$Type;
-declare class SyncFlagsResponse$Type extends MessageType<SyncFlagsResponse> {
-    constructor();
-    create(value?: PartialMessage<SyncFlagsResponse>): SyncFlagsResponse;
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SyncFlagsResponse): SyncFlagsResponse;
-    internalBinaryWrite(message: SyncFlagsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-/**
- * @generated MessageType for protobuf message sync.v1.SyncFlagsResponse
- */
-export declare const SyncFlagsResponse: SyncFlagsResponse$Type;
-declare class FetchAllFlagsRequest$Type extends MessageType<FetchAllFlagsRequest> {
-    constructor();
-    create(value?: PartialMessage<FetchAllFlagsRequest>): FetchAllFlagsRequest;
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FetchAllFlagsRequest): FetchAllFlagsRequest;
-    internalBinaryWrite(message: FetchAllFlagsRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-/**
- * @generated MessageType for protobuf message sync.v1.FetchAllFlagsRequest
- */
-export declare const FetchAllFlagsRequest: FetchAllFlagsRequest$Type;
-declare class FetchAllFlagsResponse$Type extends MessageType<FetchAllFlagsResponse> {
-    constructor();
-    create(value?: PartialMessage<FetchAllFlagsResponse>): FetchAllFlagsResponse;
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FetchAllFlagsResponse): FetchAllFlagsResponse;
-    internalBinaryWrite(message: FetchAllFlagsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-/**
- * @generated MessageType for protobuf message sync.v1.FetchAllFlagsResponse
- */
-export declare const FetchAllFlagsResponse: FetchAllFlagsResponse$Type;
-/**
- * @generated ServiceType for protobuf service sync.v1.FlagSyncService
- */
-export declare const FlagSyncService: ServiceType;
-export {};
+/// <reference types="node" />
+import { CallOptions, ChannelCredentials, Client, ClientOptions, ClientReadableStream, ClientUnaryCall, handleServerStreamingCall, handleUnaryCall, Metadata, ServiceError, UntypedServiceImplementation } from "@grpc/grpc-js";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "sync.v1";
+/**
+ * SyncState conveys the state of the payload. These states are related to flagd isync.go type definitions but
+ * contains extras to optimize grpc use case. Refer - https://github.com/open-feature/flagd/blob/main/pkg/sync/isync.go
+ */
+export declare enum SyncState {
+    /** SYNC_STATE_UNSPECIFIED - Value is ignored by the listening flagd */
+    SYNC_STATE_UNSPECIFIED = 0,
+    /**
+     * SYNC_STATE_ALL - All the flags matching the request. This is the default response and other states can be ignored
+     * by the implementation. Flagd internally replaces all existing flags for this response state.
+     */
+    SYNC_STATE_ALL = 1,
+    /** SYNC_STATE_ADD - Convey an addition of a flag. Flagd internally handles this by combining new flags with existing ones */
+    SYNC_STATE_ADD = 2,
+    /**
+     * SYNC_STATE_UPDATE - Convey an update of a flag. Flagd internally attempts to update if the updated flag already exist OR if it does not,
+     * it will get added
+     */
+    SYNC_STATE_UPDATE = 3,
+    /** SYNC_STATE_DELETE - Convey a deletion of a flag. Flagd internally removes the flag */
+    SYNC_STATE_DELETE = 4,
+    /** SYNC_STATE_PING - Optional server ping to check client connectivity. Handling is ignored by flagd and is to merely support live check */
+    SYNC_STATE_PING = 5,
+    UNRECOGNIZED = -1
+}
+export declare function syncStateFromJSON(object: any): SyncState;
+export declare function syncStateToJSON(object: SyncState): string;
+/** SyncFlagsRequest is the request initiating the sever-streaming rpc. Flagd sends this request, acting as the client */
+export interface SyncFlagsRequest {
+    /**
+     * Optional: A unique identifier for flagd(grpc client) initiating the request. The server implementations may
+     * utilize this identifier to uniquely identify, validate(ex:- enforce authentication/authorization) and filter
+     * flag configurations that it can expose to this request. This field is intended to be optional. However server
+     * implementations may enforce it.
+     *    ex:- provider_id: flagd-weatherapp-sidecar
+     */
+    providerId: string;
+    /**
+     * Optional: A selector for the flag configuration request. The server implementation may utilize this to select
+     * flag configurations from a collection, select the source of the flag or combine this to any desired underlying
+     * filtering mechanism.
+     *    ex:- selector: 'source=database,app=weatherapp'
+     */
+    selector: string;
+}
+/** SyncFlagsResponse is the server response containing feature flag configurations and the state */
+export interface SyncFlagsResponse {
+    /** flagd feature flag configuration. Must be validated to schema - https://raw.githubusercontent.com/open-feature/schemas/main/json/flagd-definitions.json */
+    flagConfiguration: string;
+    /**
+     * State conveying the operation to be performed by flagd. See the descriptions of SyncState for an explanation of
+     * supported values
+     */
+    state: SyncState;
+}
+/** FetchAllFlagsRequest is the request to fetch all flags. Flagd sends this request as the client in order to resync its internal state */
+export interface FetchAllFlagsRequest {
+    /**
+     * Optional: A unique identifier for flagd(grpc client) initiating the request. The server implementations may
+     * utilize this identifier to uniquely identify, validate(ex:- enforce authentication/authorization) and filter
+     * flag configurations that it can expose to this request. This field is intended to be optional. However server
+     * implementations may enforce it.
+     *    ex:- provider_id: flagd-weatherapp-sidecar
+     */
+    providerId: string;
+    /**
+     * Optional: A selector for the flag configuration request. The server implementation may utilize this to select
+     * flag configurations from a collection, select the source of the flag or combine this to any desired underlying
+     * filtering mechanism.
+     *    ex:- selector: 'source=database,app=weatherapp'
+     */
+    selector: string;
+}
+/** FetchAllFlagsResponse is the server response containing feature flag configurations */
+export interface FetchAllFlagsResponse {
+    /** flagd feature flag configuration. Must be validated to schema - https://raw.githubusercontent.com/open-feature/schemas/main/json/flagd-definitions.json */
+    flagConfiguration: string;
+}
+export declare const SyncFlagsRequest: {
+    encode(message: SyncFlagsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SyncFlagsRequest;
+    fromJSON(object: any): SyncFlagsRequest;
+    toJSON(message: SyncFlagsRequest): unknown;
+    create<I extends {
+        providerId?: string | undefined;
+        selector?: string | undefined;
+    } & {
+        providerId?: string | undefined;
+        selector?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof SyncFlagsRequest>]: never; }>(base?: I | undefined): SyncFlagsRequest;
+    fromPartial<I_1 extends {
+        providerId?: string | undefined;
+        selector?: string | undefined;
+    } & {
+        providerId?: string | undefined;
+        selector?: string | undefined;
+    } & { [K_1 in Exclude<keyof I_1, keyof SyncFlagsRequest>]: never; }>(object: I_1): SyncFlagsRequest;
+};
+export declare const SyncFlagsResponse: {
+    encode(message: SyncFlagsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SyncFlagsResponse;
+    fromJSON(object: any): SyncFlagsResponse;
+    toJSON(message: SyncFlagsResponse): unknown;
+    create<I extends {
+        flagConfiguration?: string | undefined;
+        state?: SyncState | undefined;
+    } & {
+        flagConfiguration?: string | undefined;
+        state?: SyncState | undefined;
+    } & { [K in Exclude<keyof I, keyof SyncFlagsResponse>]: never; }>(base?: I | undefined): SyncFlagsResponse;
+    fromPartial<I_1 extends {
+        flagConfiguration?: string | undefined;
+        state?: SyncState | undefined;
+    } & {
+        flagConfiguration?: string | undefined;
+        state?: SyncState | undefined;
+    } & { [K_1 in Exclude<keyof I_1, keyof SyncFlagsResponse>]: never; }>(object: I_1): SyncFlagsResponse;
+};
+export declare const FetchAllFlagsRequest: {
+    encode(message: FetchAllFlagsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FetchAllFlagsRequest;
+    fromJSON(object: any): FetchAllFlagsRequest;
+    toJSON(message: FetchAllFlagsRequest): unknown;
+    create<I extends {
+        providerId?: string | undefined;
+        selector?: string | undefined;
+    } & {
+        providerId?: string | undefined;
+        selector?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof FetchAllFlagsRequest>]: never; }>(base?: I | undefined): FetchAllFlagsRequest;
+    fromPartial<I_1 extends {
+        providerId?: string | undefined;
+        selector?: string | undefined;
+    } & {
+        providerId?: string | undefined;
+        selector?: string | undefined;
+    } & { [K_1 in Exclude<keyof I_1, keyof FetchAllFlagsRequest>]: never; }>(object: I_1): FetchAllFlagsRequest;
+};
+export declare const FetchAllFlagsResponse: {
+    encode(message: FetchAllFlagsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FetchAllFlagsResponse;
+    fromJSON(object: any): FetchAllFlagsResponse;
+    toJSON(message: FetchAllFlagsResponse): unknown;
+    create<I extends {
+        flagConfiguration?: string | undefined;
+    } & {
+        flagConfiguration?: string | undefined;
+    } & { [K in Exclude<keyof I, "flagConfiguration">]: never; }>(base?: I | undefined): FetchAllFlagsResponse;
+    fromPartial<I_1 extends {
+        flagConfiguration?: string | undefined;
+    } & {
+        flagConfiguration?: string | undefined;
+    } & { [K_1 in Exclude<keyof I_1, "flagConfiguration">]: never; }>(object: I_1): FetchAllFlagsResponse;
+};
+/** FlagService implements a server streaming to provide realtime flag configurations */
+export type FlagSyncServiceService = typeof FlagSyncServiceService;
+export declare const FlagSyncServiceService: {
+    readonly syncFlags: {
+        readonly path: "/sync.v1.FlagSyncService/SyncFlags";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: SyncFlagsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SyncFlagsRequest;
+        readonly responseSerialize: (value: SyncFlagsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => SyncFlagsResponse;
+    };
+    readonly fetchAllFlags: {
+        readonly path: "/sync.v1.FlagSyncService/FetchAllFlags";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: FetchAllFlagsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => FetchAllFlagsRequest;
+        readonly responseSerialize: (value: FetchAllFlagsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => FetchAllFlagsResponse;
+    };
+};
+export interface FlagSyncServiceServer extends UntypedServiceImplementation {
+    syncFlags: handleServerStreamingCall<SyncFlagsRequest, SyncFlagsResponse>;
+    fetchAllFlags: handleUnaryCall<FetchAllFlagsRequest, FetchAllFlagsResponse>;
+}
+export interface FlagSyncServiceClient extends Client {
+    syncFlags(request: SyncFlagsRequest, options?: Partial<CallOptions>): ClientReadableStream<SyncFlagsResponse>;
+    syncFlags(request: SyncFlagsRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<SyncFlagsResponse>;
+    fetchAllFlags(request: FetchAllFlagsRequest, callback: (error: ServiceError | null, response: FetchAllFlagsResponse) => void): ClientUnaryCall;
+    fetchAllFlags(request: FetchAllFlagsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: FetchAllFlagsResponse) => void): ClientUnaryCall;
+    fetchAllFlags(request: FetchAllFlagsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: FetchAllFlagsResponse) => void): ClientUnaryCall;
+}
+export declare const FlagSyncServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): FlagSyncServiceClient;
+    service: typeof FlagSyncServiceService;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/src/proto/ts/schema/v1/schema.client.d.ts

@@ -1,96 +0,0 @@
-import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
-import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
-import type { EventStreamResponse } from "./schema";
-import type { EventStreamRequest } from "./schema";
-import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
-import type { ResolveObjectResponse } from "./schema";
-import type { ResolveObjectRequest } from "./schema";
-import type { ResolveIntResponse } from "./schema";
-import type { ResolveIntRequest } from "./schema";
-import type { ResolveFloatResponse } from "./schema";
-import type { ResolveFloatRequest } from "./schema";
-import type { ResolveStringResponse } from "./schema";
-import type { ResolveStringRequest } from "./schema";
-import type { ResolveBooleanResponse } from "./schema";
-import type { ResolveBooleanRequest } from "./schema";
-import type { ResolveAllResponse } from "./schema";
-import type { ResolveAllRequest } from "./schema";
-import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
-import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
-/**
- * Service defines the exposed rpcs of flagd
- *
- * @generated from protobuf service schema.v1.Service
- */
-export interface IServiceClient {
-    /**
-     * @generated from protobuf rpc: ResolveAll(schema.v1.ResolveAllRequest) returns (schema.v1.ResolveAllResponse);
-     */
-    resolveAll(input: ResolveAllRequest, options?: RpcOptions): UnaryCall<ResolveAllRequest, ResolveAllResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveBoolean(schema.v1.ResolveBooleanRequest) returns (schema.v1.ResolveBooleanResponse);
-     */
-    resolveBoolean(input: ResolveBooleanRequest, options?: RpcOptions): UnaryCall<ResolveBooleanRequest, ResolveBooleanResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveString(schema.v1.ResolveStringRequest) returns (schema.v1.ResolveStringResponse);
-     */
-    resolveString(input: ResolveStringRequest, options?: RpcOptions): UnaryCall<ResolveStringRequest, ResolveStringResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveFloat(schema.v1.ResolveFloatRequest) returns (schema.v1.ResolveFloatResponse);
-     */
-    resolveFloat(input: ResolveFloatRequest, options?: RpcOptions): UnaryCall<ResolveFloatRequest, ResolveFloatResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveInt(schema.v1.ResolveIntRequest) returns (schema.v1.ResolveIntResponse);
-     */
-    resolveInt(input: ResolveIntRequest, options?: RpcOptions): UnaryCall<ResolveIntRequest, ResolveIntResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveObject(schema.v1.ResolveObjectRequest) returns (schema.v1.ResolveObjectResponse);
-     */
-    resolveObject(input: ResolveObjectRequest, options?: RpcOptions): UnaryCall<ResolveObjectRequest, ResolveObjectResponse>;
-    /**
-     * @generated from protobuf rpc: EventStream(schema.v1.EventStreamRequest) returns (stream schema.v1.EventStreamResponse);
-     */
-    eventStream(input: EventStreamRequest, options?: RpcOptions): ServerStreamingCall<EventStreamRequest, EventStreamResponse>;
-}
-/**
- * Service defines the exposed rpcs of flagd
- *
- * @generated from protobuf service schema.v1.Service
- */
-export declare class ServiceClient implements IServiceClient, ServiceInfo {
-    private readonly _transport;
-    typeName: string;
-    methods: import("@protobuf-ts/runtime-rpc").MethodInfo<any, any>[];
-    options: {
-        [extensionName: string]: import("@protobuf-ts/runtime").JsonValue;
-    };
-    constructor(_transport: RpcTransport);
-    /**
-     * @generated from protobuf rpc: ResolveAll(schema.v1.ResolveAllRequest) returns (schema.v1.ResolveAllResponse);
-     */
-    resolveAll(input: ResolveAllRequest, options?: RpcOptions): UnaryCall<ResolveAllRequest, ResolveAllResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveBoolean(schema.v1.ResolveBooleanRequest) returns (schema.v1.ResolveBooleanResponse);
-     */
-    resolveBoolean(input: ResolveBooleanRequest, options?: RpcOptions): UnaryCall<ResolveBooleanRequest, ResolveBooleanResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveString(schema.v1.ResolveStringRequest) returns (schema.v1.ResolveStringResponse);
-     */
-    resolveString(input: ResolveStringRequest, options?: RpcOptions): UnaryCall<ResolveStringRequest, ResolveStringResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveFloat(schema.v1.ResolveFloatRequest) returns (schema.v1.ResolveFloatResponse);
-     */
-    resolveFloat(input: ResolveFloatRequest, options?: RpcOptions): UnaryCall<ResolveFloatRequest, ResolveFloatResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveInt(schema.v1.ResolveIntRequest) returns (schema.v1.ResolveIntResponse);
-     */
-    resolveInt(input: ResolveIntRequest, options?: RpcOptions): UnaryCall<ResolveIntRequest, ResolveIntResponse>;
-    /**
-     * @generated from protobuf rpc: ResolveObject(schema.v1.ResolveObjectRequest) returns (schema.v1.ResolveObjectResponse);
-     */
-    resolveObject(input: ResolveObjectRequest, options?: RpcOptions): UnaryCall<ResolveObjectRequest, ResolveObjectResponse>;
-    /**
-     * @generated from protobuf rpc: EventStream(schema.v1.EventStreamRequest) returns (stream schema.v1.EventStreamResponse);
-     */
-    eventStream(input: EventStreamRequest, options?: RpcOptions): ServerStreamingCall<EventStreamRequest, EventStreamResponse>;
-}

package/src/proto/ts/sync/v1/sync_service.client.d.ts

@@ -1,46 +0,0 @@
-import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
-import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
-import type { FetchAllFlagsResponse } from "./sync_service";
-import type { FetchAllFlagsRequest } from "./sync_service";
-import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
-import type { SyncFlagsResponse } from "./sync_service";
-import type { SyncFlagsRequest } from "./sync_service";
-import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
-import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
-/**
- * FlagService implements a server streaming to provide realtime flag configurations
- *
- * @generated from protobuf service sync.v1.FlagSyncService
- */
-export interface IFlagSyncServiceClient {
-    /**
-     * @generated from protobuf rpc: SyncFlags(sync.v1.SyncFlagsRequest) returns (stream sync.v1.SyncFlagsResponse);
-     */
-    syncFlags(input: SyncFlagsRequest, options?: RpcOptions): ServerStreamingCall<SyncFlagsRequest, SyncFlagsResponse>;
-    /**
-     * @generated from protobuf rpc: FetchAllFlags(sync.v1.FetchAllFlagsRequest) returns (sync.v1.FetchAllFlagsResponse);
-     */
-    fetchAllFlags(input: FetchAllFlagsRequest, options?: RpcOptions): UnaryCall<FetchAllFlagsRequest, FetchAllFlagsResponse>;
-}
-/**
- * FlagService implements a server streaming to provide realtime flag configurations
- *
- * @generated from protobuf service sync.v1.FlagSyncService
- */
-export declare class FlagSyncServiceClient implements IFlagSyncServiceClient, ServiceInfo {
-    private readonly _transport;
-    typeName: string;
-    methods: import("@protobuf-ts/runtime-rpc").MethodInfo<any, any>[];
-    options: {
-        [extensionName: string]: import("@protobuf-ts/runtime").JsonValue;
-    };
-    constructor(_transport: RpcTransport);
-    /**
-     * @generated from protobuf rpc: SyncFlags(sync.v1.SyncFlagsRequest) returns (stream sync.v1.SyncFlagsResponse);
-     */
-    syncFlags(input: SyncFlagsRequest, options?: RpcOptions): ServerStreamingCall<SyncFlagsRequest, SyncFlagsResponse>;
-    /**
-     * @generated from protobuf rpc: FetchAllFlags(sync.v1.FetchAllFlagsRequest) returns (sync.v1.FetchAllFlagsResponse);
-     */
-    fetchAllFlags(input: FetchAllFlagsRequest, options?: RpcOptions): UnaryCall<FetchAllFlagsRequest, FetchAllFlagsResponse>;
-}