@wundergraph/cosmo-connect/dist/node/v1/node_pb.d.ts

TypeScript Connect client for WunderGraph Cosmo

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { EnumStatusCode, GraphQLSubscriptionProtocol, GraphQLWebsocketSubprotocol } from "../../common/common_pb.js";
/**
 * @generated from enum wg.cosmo.node.v1.ArgumentRenderConfiguration
 */
export declare enum ArgumentRenderConfiguration {
    /**
     * @generated from enum value: RENDER_ARGUMENT_DEFAULT = 0;
     */
    RENDER_ARGUMENT_DEFAULT = 0,
    /**
     * @generated from enum value: RENDER_ARGUMENT_AS_GRAPHQL_VALUE = 1;
     */
    RENDER_ARGUMENT_AS_GRAPHQL_VALUE = 1,
    /**
     * @generated from enum value: RENDER_ARGUMENT_AS_ARRAY_CSV = 2;
     */
    RENDER_ARGUMENT_AS_ARRAY_CSV = 2
}
/**
 * @generated from enum wg.cosmo.node.v1.ArgumentSource
 */
export declare enum ArgumentSource {
    /**
     * @generated from enum value: OBJECT_FIELD = 0;
     */
    OBJECT_FIELD = 0,
    /**
     * @generated from enum value: FIELD_ARGUMENT = 1;
     */
    FIELD_ARGUMENT = 1
}
/**
 * @generated from enum wg.cosmo.node.v1.DataSourceKind
 */
export declare enum DataSourceKind {
    /**
     * @generated from enum value: STATIC = 0;
     */
    STATIC = 0,
    /**
     * @generated from enum value: GRAPHQL = 1;
     */
    GRAPHQL = 1,
    /**
     * @generated from enum value: PUBSUB = 2;
     */
    PUBSUB = 2
}
/**
 * Defines the type of GraphQL operation
 *
 * @generated from enum wg.cosmo.node.v1.OperationType
 */
export declare enum OperationType {
    /**
     * @generated from enum value: OPERATION_TYPE_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * Query operation
     *
     * @generated from enum value: OPERATION_TYPE_QUERY = 1;
     */
    QUERY = 1,
    /**
     * Mutation operation
     *
     * @generated from enum value: OPERATION_TYPE_MUTATION = 2;
     */
    MUTATION = 2,
    /**
     * Subscription operation
     *
     * @generated from enum value: OPERATION_TYPE_SUBSCRIPTION = 3;
     */
    SUBSCRIPTION = 3
}
/**
 * @generated from enum wg.cosmo.node.v1.EventType
 */
export declare enum EventType {
    /**
     * @generated from enum value: PUBLISH = 0;
     */
    PUBLISH = 0,
    /**
     * @generated from enum value: REQUEST = 1;
     */
    REQUEST = 1,
    /**
     * @generated from enum value: SUBSCRIBE = 2;
     */
    SUBSCRIBE = 2
}
/**
 * @generated from enum wg.cosmo.node.v1.ConfigurationVariableKind
 */
export declare enum ConfigurationVariableKind {
    /**
     * @generated from enum value: STATIC_CONFIGURATION_VARIABLE = 0;
     */
    STATIC_CONFIGURATION_VARIABLE = 0,
    /**
     * @generated from enum value: ENV_CONFIGURATION_VARIABLE = 1;
     */
    ENV_CONFIGURATION_VARIABLE = 1,
    /**
     * @generated from enum value: PLACEHOLDER_CONFIGURATION_VARIABLE = 2;
     */
    PLACEHOLDER_CONFIGURATION_VARIABLE = 2
}
/**
 * @generated from enum wg.cosmo.node.v1.HTTPMethod
 */
export declare enum HTTPMethod {
    /**
     * @generated from enum value: GET = 0;
     */
    GET = 0,
    /**
     * @generated from enum value: POST = 1;
     */
    POST = 1,
    /**
     * @generated from enum value: PUT = 2;
     */
    PUT = 2,
    /**
     * @generated from enum value: DELETE = 3;
     */
    DELETE = 3,
    /**
     * @generated from enum value: OPTIONS = 4;
     */
    OPTIONS = 4
}
/**
 * @generated from message wg.cosmo.node.v1.Subgraph
 */
export declare class Subgraph extends Message<Subgraph> {
    /**
     * @generated from field: string id = 1;
     */
    id: string;
    /**
     * @generated from field: string name = 2;
     */
    name: string;
    /**
     * @generated from field: string routing_url = 3;
     */
    routingUrl: string;
    constructor(data?: PartialMessage<Subgraph>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.Subgraph";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Subgraph;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Subgraph;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Subgraph;
    static equals(a: Subgraph | PlainMessage<Subgraph> | undefined, b: Subgraph | PlainMessage<Subgraph> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.FeatureFlagRouterExecutionConfigs
 */
export declare class FeatureFlagRouterExecutionConfigs extends Message<FeatureFlagRouterExecutionConfigs> {
    /**
     * @generated from field: map<string, wg.cosmo.node.v1.FeatureFlagRouterExecutionConfig> config_by_feature_flag_name = 1;
     */
    configByFeatureFlagName: {
        [key: string]: FeatureFlagRouterExecutionConfig;
    };
    constructor(data?: PartialMessage<FeatureFlagRouterExecutionConfigs>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.FeatureFlagRouterExecutionConfigs";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeatureFlagRouterExecutionConfigs;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeatureFlagRouterExecutionConfigs;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeatureFlagRouterExecutionConfigs;
    static equals(a: FeatureFlagRouterExecutionConfigs | PlainMessage<FeatureFlagRouterExecutionConfigs> | undefined, b: FeatureFlagRouterExecutionConfigs | PlainMessage<FeatureFlagRouterExecutionConfigs> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.FeatureFlagRouterExecutionConfig
 */
export declare class FeatureFlagRouterExecutionConfig extends Message<FeatureFlagRouterExecutionConfig> {
    /**
     * @generated from field: wg.cosmo.node.v1.EngineConfiguration engine_config = 1;
     */
    engineConfig?: EngineConfiguration;
    /**
     * @generated from field: string version = 2;
     */
    version: string;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.Subgraph subgraphs = 3;
     */
    subgraphs: Subgraph[];
    constructor(data?: PartialMessage<FeatureFlagRouterExecutionConfig>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.FeatureFlagRouterExecutionConfig";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeatureFlagRouterExecutionConfig;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeatureFlagRouterExecutionConfig;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeatureFlagRouterExecutionConfig;
    static equals(a: FeatureFlagRouterExecutionConfig | PlainMessage<FeatureFlagRouterExecutionConfig> | undefined, b: FeatureFlagRouterExecutionConfig | PlainMessage<FeatureFlagRouterExecutionConfig> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.RouterConfig
 */
export declare class RouterConfig extends Message<RouterConfig> {
    /**
     * @generated from field: wg.cosmo.node.v1.EngineConfiguration engine_config = 1;
     */
    engineConfig?: EngineConfiguration;
    /**
     * @generated from field: string version = 2;
     */
    version: string;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.Subgraph subgraphs = 3;
     */
    subgraphs: Subgraph[];
    /**
     * The map of feature flag router execution configs requires a wrapper to be non-breaking
     *
     * @generated from field: optional wg.cosmo.node.v1.FeatureFlagRouterExecutionConfigs feature_flag_configs = 4;
     */
    featureFlagConfigs?: FeatureFlagRouterExecutionConfigs;
    /**
     * @generated from field: string compatibility_version = 5;
     */
    compatibilityVersion: string;
    constructor(data?: PartialMessage<RouterConfig>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.RouterConfig";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RouterConfig;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RouterConfig;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RouterConfig;
    static equals(a: RouterConfig | PlainMessage<RouterConfig> | undefined, b: RouterConfig | PlainMessage<RouterConfig> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.Response
 */
export declare class Response extends Message<Response> {
    /**
     * @generated from field: wg.cosmo.common.EnumStatusCode code = 1;
     */
    code: EnumStatusCode;
    /**
     * details is an optional field which can be used to provide more details about the error.
     *
     * @generated from field: optional string details = 2;
     */
    details?: string;
    constructor(data?: PartialMessage<Response>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.Response";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Response;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Response;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Response;
    static equals(a: Response | PlainMessage<Response> | undefined, b: Response | PlainMessage<Response> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.ResponseStatus
 */
export declare class ResponseStatus extends Message<ResponseStatus> {
    /**
     * @generated from field: int32 code = 1;
     */
    code: number;
    /**
     * @generated from field: string message = 2;
     */
    message: string;
    constructor(data?: PartialMessage<ResponseStatus>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.ResponseStatus";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseStatus;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseStatus;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseStatus;
    static equals(a: ResponseStatus | PlainMessage<ResponseStatus> | undefined, b: ResponseStatus | PlainMessage<ResponseStatus> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.RegistrationInfo
 */
export declare class RegistrationInfo extends Message<RegistrationInfo> {
    /**
     * @generated from field: wg.cosmo.node.v1.AccountLimits account_limits = 1;
     */
    accountLimits?: AccountLimits;
    /**
     * @generated from field: string graph_public_key = 2;
     */
    graphPublicKey: string;
    constructor(data?: PartialMessage<RegistrationInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.RegistrationInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegistrationInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegistrationInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegistrationInfo;
    static equals(a: RegistrationInfo | PlainMessage<RegistrationInfo> | undefined, b: RegistrationInfo | PlainMessage<RegistrationInfo> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.AccountLimits
 */
export declare class AccountLimits extends Message<AccountLimits> {
    /**
     * The maximum sampling rate for traces. Must be between 0 and 1.
     * 0 means no traces will be sampled and 1 means all traces will be sampled.
     *
     * @generated from field: float trace_sampling_rate = 1;
     */
    traceSamplingRate: number;
    constructor(data?: PartialMessage<AccountLimits>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.AccountLimits";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AccountLimits;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AccountLimits;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AccountLimits;
    static equals(a: AccountLimits | PlainMessage<AccountLimits> | undefined, b: AccountLimits | PlainMessage<AccountLimits> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.SelfRegisterRequest
 */
export declare class SelfRegisterRequest extends Message<SelfRegisterRequest> {
    constructor(data?: PartialMessage<SelfRegisterRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.SelfRegisterRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SelfRegisterRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SelfRegisterRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SelfRegisterRequest;
    static equals(a: SelfRegisterRequest | PlainMessage<SelfRegisterRequest> | undefined, b: SelfRegisterRequest | PlainMessage<SelfRegisterRequest> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.SelfRegisterResponse
 */
export declare class SelfRegisterResponse extends Message<SelfRegisterResponse> {
    /**
     * @generated from field: wg.cosmo.node.v1.Response response = 1;
     */
    response?: Response;
    /**
     * @generated from field: optional wg.cosmo.node.v1.RegistrationInfo registrationInfo = 2;
     */
    registrationInfo?: RegistrationInfo;
    constructor(data?: PartialMessage<SelfRegisterResponse>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.SelfRegisterResponse";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SelfRegisterResponse;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SelfRegisterResponse;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SelfRegisterResponse;
    static equals(a: SelfRegisterResponse | PlainMessage<SelfRegisterResponse> | undefined, b: SelfRegisterResponse | PlainMessage<SelfRegisterResponse> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.EngineConfiguration
 */
export declare class EngineConfiguration extends Message<EngineConfiguration> {
    /**
     * @generated from field: int64 defaultFlushInterval = 1;
     */
    defaultFlushInterval: bigint;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.DataSourceConfiguration datasource_configurations = 2;
     */
    datasourceConfigurations: DataSourceConfiguration[];
    /**
     * @generated from field: repeated wg.cosmo.node.v1.FieldConfiguration field_configurations = 3;
     */
    fieldConfigurations: FieldConfiguration[];
    /**
     * @generated from field: string graphqlSchema = 4;
     */
    graphqlSchema: string;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.TypeConfiguration type_configurations = 5;
     */
    typeConfigurations: TypeConfiguration[];
    /**
     * @generated from field: map<string, string> string_storage = 6;
     */
    stringStorage: {
        [key: string]: string;
    };
    /**
     * @generated from field: optional string graphql_client_schema = 7;
     */
    graphqlClientSchema?: string;
    constructor(data?: PartialMessage<EngineConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.EngineConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EngineConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EngineConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EngineConfiguration;
    static equals(a: EngineConfiguration | PlainMessage<EngineConfiguration> | undefined, b: EngineConfiguration | PlainMessage<EngineConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.DataSourceConfiguration
 */
export declare class DataSourceConfiguration extends Message<DataSourceConfiguration> {
    /**
     * @generated from field: wg.cosmo.node.v1.DataSourceKind kind = 1;
     */
    kind: DataSourceKind;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.TypeField root_nodes = 2;
     */
    rootNodes: TypeField[];
    /**
     * @generated from field: repeated wg.cosmo.node.v1.TypeField child_nodes = 3;
     */
    childNodes: TypeField[];
    /**
     * @generated from field: bool override_field_path_from_alias = 4;
     */
    overrideFieldPathFromAlias: boolean;
    /**
     * @generated from field: wg.cosmo.node.v1.DataSourceCustom_GraphQL custom_graphql = 5;
     */
    customGraphql?: DataSourceCustom_GraphQL;
    /**
     * @generated from field: wg.cosmo.node.v1.DataSourceCustom_Static custom_static = 6;
     */
    customStatic?: DataSourceCustom_Static;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.DirectiveConfiguration directives = 7;
     */
    directives: DirectiveConfiguration[];
    /**
     * @generated from field: int64 request_timeout_seconds = 8;
     */
    requestTimeoutSeconds: bigint;
    /**
     * @generated from field: string id = 9;
     */
    id: string;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.RequiredField keys = 10;
     */
    keys: RequiredField[];
    /**
     * @generated from field: repeated wg.cosmo.node.v1.RequiredField provides = 11;
     */
    provides: RequiredField[];
    /**
     * @generated from field: repeated wg.cosmo.node.v1.RequiredField requires = 12;
     */
    requires: RequiredField[];
    /**
     * @generated from field: wg.cosmo.node.v1.DataSourceCustomEvents custom_events = 13;
     */
    customEvents?: DataSourceCustomEvents;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.EntityInterfaceConfiguration entity_interfaces = 14;
     */
    entityInterfaces: EntityInterfaceConfiguration[];
    /**
     * @generated from field: repeated wg.cosmo.node.v1.EntityInterfaceConfiguration interface_objects = 15;
     */
    interfaceObjects: EntityInterfaceConfiguration[];
    constructor(data?: PartialMessage<DataSourceConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.DataSourceConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataSourceConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataSourceConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataSourceConfiguration;
    static equals(a: DataSourceConfiguration | PlainMessage<DataSourceConfiguration> | undefined, b: DataSourceConfiguration | PlainMessage<DataSourceConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.ArgumentConfiguration
 */
export declare class ArgumentConfiguration extends Message<ArgumentConfiguration> {
    /**
     * @generated from field: string name = 1;
     */
    name: string;
    /**
     * @generated from field: wg.cosmo.node.v1.ArgumentSource source_type = 2;
     */
    sourceType: ArgumentSource;
    constructor(data?: PartialMessage<ArgumentConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.ArgumentConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ArgumentConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ArgumentConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ArgumentConfiguration;
    static equals(a: ArgumentConfiguration | PlainMessage<ArgumentConfiguration> | undefined, b: ArgumentConfiguration | PlainMessage<ArgumentConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.Scopes
 */
export declare class Scopes extends Message<Scopes> {
    /**
     * @generated from field: repeated string required_and_scopes = 1;
     */
    requiredAndScopes: string[];
    constructor(data?: PartialMessage<Scopes>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.Scopes";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Scopes;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Scopes;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Scopes;
    static equals(a: Scopes | PlainMessage<Scopes> | undefined, b: Scopes | PlainMessage<Scopes> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.AuthorizationConfiguration
 */
export declare class AuthorizationConfiguration extends Message<AuthorizationConfiguration> {
    /**
     * @generated from field: bool requires_authentication = 1;
     */
    requiresAuthentication: boolean;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.Scopes required_or_scopes = 2;
     */
    requiredOrScopes: Scopes[];
    /**
     * @generated from field: repeated wg.cosmo.node.v1.Scopes required_or_scopes_by_or = 3;
     */
    requiredOrScopesByOr: Scopes[];
    constructor(data?: PartialMessage<AuthorizationConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.AuthorizationConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AuthorizationConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AuthorizationConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AuthorizationConfiguration;
    static equals(a: AuthorizationConfiguration | PlainMessage<AuthorizationConfiguration> | undefined, b: AuthorizationConfiguration | PlainMessage<AuthorizationConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.FieldConfiguration
 */
export declare class FieldConfiguration extends Message<FieldConfiguration> {
    /**
     * @generated from field: string type_name = 1;
     */
    typeName: string;
    /**
     * @generated from field: string field_name = 2;
     */
    fieldName: string;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.ArgumentConfiguration arguments_configuration = 3;
     */
    argumentsConfiguration: ArgumentConfiguration[];
    /**
     * @generated from field: wg.cosmo.node.v1.AuthorizationConfiguration authorization_configuration = 4;
     */
    authorizationConfiguration?: AuthorizationConfiguration;
    /**
     * @generated from field: optional wg.cosmo.node.v1.SubscriptionFilterCondition subscription_filter_condition = 5;
     */
    subscriptionFilterCondition?: SubscriptionFilterCondition;
    constructor(data?: PartialMessage<FieldConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.FieldConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FieldConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FieldConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FieldConfiguration;
    static equals(a: FieldConfiguration | PlainMessage<FieldConfiguration> | undefined, b: FieldConfiguration | PlainMessage<FieldConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.TypeConfiguration
 */
export declare class TypeConfiguration extends Message<TypeConfiguration> {
    /**
     * @generated from field: string type_name = 1;
     */
    typeName: string;
    /**
     * @generated from field: string rename_to = 2;
     */
    renameTo: string;
    constructor(data?: PartialMessage<TypeConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.TypeConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TypeConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TypeConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TypeConfiguration;
    static equals(a: TypeConfiguration | PlainMessage<TypeConfiguration> | undefined, b: TypeConfiguration | PlainMessage<TypeConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.TypeField
 */
export declare class TypeField extends Message<TypeField> {
    /**
     * @generated from field: string type_name = 1;
     */
    typeName: string;
    /**
     * @generated from field: repeated string field_names = 2;
     */
    fieldNames: string[];
    /**
     * @generated from field: repeated string external_field_names = 3;
     */
    externalFieldNames: string[];
    constructor(data?: PartialMessage<TypeField>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.TypeField";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TypeField;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TypeField;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TypeField;
    static equals(a: TypeField | PlainMessage<TypeField> | undefined, b: TypeField | PlainMessage<TypeField> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.FieldCoordinates
 */
export declare class FieldCoordinates extends Message<FieldCoordinates> {
    /**
     * @generated from field: string field_name = 1;
     */
    fieldName: string;
    /**
     * @generated from field: string type_name = 2;
     */
    typeName: string;
    constructor(data?: PartialMessage<FieldCoordinates>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.FieldCoordinates";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FieldCoordinates;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FieldCoordinates;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FieldCoordinates;
    static equals(a: FieldCoordinates | PlainMessage<FieldCoordinates> | undefined, b: FieldCoordinates | PlainMessage<FieldCoordinates> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.FieldSetCondition
 */
export declare class FieldSetCondition extends Message<FieldSetCondition> {
    /**
     * @generated from field: repeated wg.cosmo.node.v1.FieldCoordinates field_coordinates_path = 1;
     */
    fieldCoordinatesPath: FieldCoordinates[];
    /**
     * @generated from field: repeated string field_path = 2;
     */
    fieldPath: string[];
    constructor(data?: PartialMessage<FieldSetCondition>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.FieldSetCondition";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FieldSetCondition;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FieldSetCondition;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FieldSetCondition;
    static equals(a: FieldSetCondition | PlainMessage<FieldSetCondition> | undefined, b: FieldSetCondition | PlainMessage<FieldSetCondition> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.RequiredField
 */
export declare class RequiredField extends Message<RequiredField> {
    /**
     * @generated from field: string type_name = 1;
     */
    typeName: string;
    /**
     * @generated from field: string field_name = 2;
     */
    fieldName: string;
    /**
     * @generated from field: string selection_set = 3;
     */
    selectionSet: string;
    /**
     * @generated from field: bool disable_entity_resolver = 4;
     */
    disableEntityResolver: boolean;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.FieldSetCondition conditions = 5;
     */
    conditions: FieldSetCondition[];
    constructor(data?: PartialMessage<RequiredField>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.RequiredField";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequiredField;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequiredField;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequiredField;
    static equals(a: RequiredField | PlainMessage<RequiredField> | undefined, b: RequiredField | PlainMessage<RequiredField> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.EntityInterfaceConfiguration
 */
export declare class EntityInterfaceConfiguration extends Message<EntityInterfaceConfiguration> {
    /**
     * @generated from field: string interface_type_name = 1;
     */
    interfaceTypeName: string;
    /**
     * @generated from field: repeated string concrete_type_names = 2;
     */
    concreteTypeNames: string[];
    constructor(data?: PartialMessage<EntityInterfaceConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.EntityInterfaceConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EntityInterfaceConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EntityInterfaceConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EntityInterfaceConfiguration;
    static equals(a: EntityInterfaceConfiguration | PlainMessage<EntityInterfaceConfiguration> | undefined, b: EntityInterfaceConfiguration | PlainMessage<EntityInterfaceConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.FetchConfiguration
 */
export declare class FetchConfiguration extends Message<FetchConfiguration> {
    /**
     * You should either configure url OR a combination of baseURL and path
     * If url resolves to a non empty string, it takes precedence over baseURL and path
     * If url resolves to an empty string, the url will be configured as "{{baseURL}}{{path}}"
     *
     * @generated from field: wg.cosmo.node.v1.ConfigurationVariable url = 1;
     */
    url?: ConfigurationVariable;
    /**
     * @generated from field: wg.cosmo.node.v1.HTTPMethod method = 2;
     */
    method: HTTPMethod;
    /**
     * @generated from field: map<string, wg.cosmo.node.v1.HTTPHeader> header = 3;
     */
    header: {
        [key: string]: HTTPHeader;
    };
    /**
     * @generated from field: wg.cosmo.node.v1.ConfigurationVariable body = 4;
     */
    body?: ConfigurationVariable;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.URLQueryConfiguration query = 5;
     */
    query: URLQueryConfiguration[];
    /**
     * urlEncodeBody defines whether the body should be URL encoded or not
     * by default, the body will be JSON encoded
     * setting urlEncodeBody to true will render the body empty,
     * the Header Content-Type will be set to application/x-www-form-urlencoded,
     * and the body will be URL encoded and set as the URL Query String
     *
     * @generated from field: bool url_encode_body = 7;
     */
    urlEncodeBody: boolean;
    /**
     * @generated from field: wg.cosmo.node.v1.MTLSConfiguration mtls = 8;
     */
    mtls?: MTLSConfiguration;
    /**
     * @generated from field: wg.cosmo.node.v1.ConfigurationVariable base_url = 9;
     */
    baseUrl?: ConfigurationVariable;
    /**
     * @generated from field: wg.cosmo.node.v1.ConfigurationVariable path = 10;
     */
    path?: ConfigurationVariable;
    /**
     * @generated from field: optional wg.cosmo.node.v1.ConfigurationVariable http_proxy_url = 11;
     */
    httpProxyUrl?: ConfigurationVariable;
    constructor(data?: PartialMessage<FetchConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.FetchConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FetchConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FetchConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FetchConfiguration;
    static equals(a: FetchConfiguration | PlainMessage<FetchConfiguration> | undefined, b: FetchConfiguration | PlainMessage<FetchConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.StatusCodeTypeMapping
 */
export declare class StatusCodeTypeMapping extends Message<StatusCodeTypeMapping> {
    /**
     * @generated from field: int64 status_code = 1;
     */
    statusCode: bigint;
    /**
     * @generated from field: string type_name = 2;
     */
    typeName: string;
    /**
     * @generated from field: bool inject_status_code_into_body = 3;
     */
    injectStatusCodeIntoBody: boolean;
    constructor(data?: PartialMessage<StatusCodeTypeMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.StatusCodeTypeMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StatusCodeTypeMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StatusCodeTypeMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StatusCodeTypeMapping;
    static equals(a: StatusCodeTypeMapping | PlainMessage<StatusCodeTypeMapping> | undefined, b: StatusCodeTypeMapping | PlainMessage<StatusCodeTypeMapping> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.DataSourceCustom_GraphQL
 */
export declare class DataSourceCustom_GraphQL extends Message<DataSourceCustom_GraphQL> {
    /**
     * @generated from field: wg.cosmo.node.v1.FetchConfiguration fetch = 1;
     */
    fetch?: FetchConfiguration;
    /**
     * @generated from field: wg.cosmo.node.v1.GraphQLSubscriptionConfiguration subscription = 2;
     */
    subscription?: GraphQLSubscriptionConfiguration;
    /**
     * @generated from field: wg.cosmo.node.v1.GraphQLFederationConfiguration federation = 3;
     */
    federation?: GraphQLFederationConfiguration;
    /**
     * @generated from field: wg.cosmo.node.v1.InternedString upstream_schema = 4;
     */
    upstreamSchema?: InternedString;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.SingleTypeField custom_scalar_type_fields = 6;
     */
    customScalarTypeFields: SingleTypeField[];
    /**
     * @generated from field: wg.cosmo.node.v1.GRPCConfiguration grpc = 7;
     */
    grpc?: GRPCConfiguration;
    constructor(data?: PartialMessage<DataSourceCustom_GraphQL>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.DataSourceCustom_GraphQL";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataSourceCustom_GraphQL;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataSourceCustom_GraphQL;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataSourceCustom_GraphQL;
    static equals(a: DataSourceCustom_GraphQL | PlainMessage<DataSourceCustom_GraphQL> | undefined, b: DataSourceCustom_GraphQL | PlainMessage<DataSourceCustom_GraphQL> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.GRPCConfiguration
 */
export declare class GRPCConfiguration extends Message<GRPCConfiguration> {
    /**
     * @generated from field: wg.cosmo.node.v1.GRPCMapping mapping = 1;
     */
    mapping?: GRPCMapping;
    /**
     * @generated from field: string proto_schema = 2;
     */
    protoSchema: string;
    /**
     * @generated from field: wg.cosmo.node.v1.PluginConfiguration plugin = 3;
     */
    plugin?: PluginConfiguration;
    constructor(data?: PartialMessage<GRPCConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.GRPCConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GRPCConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GRPCConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GRPCConfiguration;
    static equals(a: GRPCConfiguration | PlainMessage<GRPCConfiguration> | undefined, b: GRPCConfiguration | PlainMessage<GRPCConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.ImageReference
 */
export declare class ImageReference extends Message<ImageReference> {
    /**
     * {organization_id}/{subgraph_id}
     *
     * @generated from field: string repository = 1;
     */
    repository: string;
    /**
     * v1
     *
     * @generated from field: string reference = 2;
     */
    reference: string;
    constructor(data?: PartialMessage<ImageReference>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.ImageReference";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ImageReference;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ImageReference;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ImageReference;
    static equals(a: ImageReference | PlainMessage<ImageReference> | undefined, b: ImageReference | PlainMessage<ImageReference> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.PluginConfiguration
 */
export declare class PluginConfiguration extends Message<PluginConfiguration> {
    /**
     * Plugin name
     *
     * @generated from field: string name = 1;
     */
    name: string;
    /**
     * Plugin version
     *
     * @generated from field: string version = 2;
     */
    version: string;
    /**
     * @generated from field: optional wg.cosmo.node.v1.ImageReference image_reference = 3;
     */
    imageReference?: ImageReference;
    constructor(data?: PartialMessage<PluginConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.PluginConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PluginConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PluginConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PluginConfiguration;
    static equals(a: PluginConfiguration | PlainMessage<PluginConfiguration> | undefined, b: PluginConfiguration | PlainMessage<PluginConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.SSLConfiguration
 */
export declare class SSLConfiguration extends Message<SSLConfiguration> {
    /**
     * Whether SSL is enabled
     *
     * @generated from field: bool enabled = 1;
     */
    enabled: boolean;
    constructor(data?: PartialMessage<SSLConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.SSLConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SSLConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SSLConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SSLConfiguration;
    static equals(a: SSLConfiguration | PlainMessage<SSLConfiguration> | undefined, b: SSLConfiguration | PlainMessage<SSLConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.GRPCMapping
 */
export declare class GRPCMapping extends Message<GRPCMapping> {
    /**
     * Version of the mapping format
     *
     * @generated from field: int32 version = 1;
     */
    version: number;
    /**
     * The main gRPC service name
     *
     * @generated from field: string service = 2;
     */
    service: string;
    /**
     * Mappings for GraphQL operations to gRPC RPCs
     *
     * @generated from field: repeated wg.cosmo.node.v1.OperationMapping operation_mappings = 3;
     */
    operationMappings: OperationMapping[];
    /**
     * Mappings for GraphQL entities to gRPC service methods
     *
     * @generated from field: repeated wg.cosmo.node.v1.EntityMapping entity_mappings = 4;
     */
    entityMappings: EntityMapping[];
    /**
     * Mappings for GraphQL type fields to gRPC message fields
     *
     * @generated from field: repeated wg.cosmo.node.v1.TypeFieldMapping type_field_mappings = 5;
     */
    typeFieldMappings: TypeFieldMapping[];
    /**
     * Mappings for GraphQL enum values to gRPC enum values
     *
     * @generated from field: repeated wg.cosmo.node.v1.EnumMapping enum_mappings = 6;
     */
    enumMappings: EnumMapping[];
    constructor(data?: PartialMessage<GRPCMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.GRPCMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GRPCMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GRPCMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GRPCMapping;
    static equals(a: GRPCMapping | PlainMessage<GRPCMapping> | undefined, b: GRPCMapping | PlainMessage<GRPCMapping> | undefined): boolean;
}
/**
 * Defines mapping between a GraphQL operation and a gRPC method
 *
 * @generated from message wg.cosmo.node.v1.OperationMapping
 */
export declare class OperationMapping extends Message<OperationMapping> {
    /**
     * GraphQL operation type: Query, Mutation, or Subscription
     *
     * @generated from field: wg.cosmo.node.v1.OperationType type = 1;
     */
    type: OperationType;
    /**
     * Original GraphQL field name
     *
     * @generated from field: string original = 2;
     */
    original: string;
    /**
     * Mapped gRPC method name
     *
     * @generated from field: string mapped = 3;
     */
    mapped: string;
    /**
     * gRPC request message type name
     *
     * @generated from field: string request = 4;
     */
    request: string;
    /**
     * gRPC response message type name
     *
     * @generated from field: string response = 5;
     */
    response: string;
    constructor(data?: PartialMessage<OperationMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.OperationMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OperationMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OperationMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OperationMapping;
    static equals(a: OperationMapping | PlainMessage<OperationMapping> | undefined, b: OperationMapping | PlainMessage<OperationMapping> | undefined): boolean;
}
/**
 * Defines mapping for entity resolution
 *
 * @generated from message wg.cosmo.node.v1.EntityMapping
 */
export declare class EntityMapping extends Message<EntityMapping> {
    /**
     * GraphQL type name
     *
     * @generated from field: string type_name = 1;
     */
    typeName: string;
    /**
     * Kind of entity mapping: "entity", "requires", or "with_arguments"
     *
     * @generated from field: string kind = 2;
     */
    kind: string;
    /**
     * Key field that uniquely identifies the entity
     *
     * @generated from field: string key = 3;
     */
    key: string;
    /**
     * gRPC method name for entity resolution
     *
     * @generated from field: string rpc = 4;
     */
    rpc: string;
    /**
     * gRPC request message type name
     *
     * @generated from field: string request = 5;
     */
    request: string;
    /**
     * gRPC response message type name
     *
     * @generated from field: string response = 6;
     */
    response: string;
    constructor(data?: PartialMessage<EntityMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.EntityMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EntityMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EntityMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EntityMapping;
    static equals(a: EntityMapping | PlainMessage<EntityMapping> | undefined, b: EntityMapping | PlainMessage<EntityMapping> | undefined): boolean;
}
/**
 * Defines mapping between GraphQL type fields and gRPC message fields
 *
 * @generated from message wg.cosmo.node.v1.TypeFieldMapping
 */
export declare class TypeFieldMapping extends Message<TypeFieldMapping> {
    /**
     * GraphQL type name
     *
     * @generated from field: string type = 1;
     */
    type: string;
    /**
     * Mappings for each field in the type
     *
     * @generated from field: repeated wg.cosmo.node.v1.FieldMapping field_mappings = 2;
     */
    fieldMappings: FieldMapping[];
    constructor(data?: PartialMessage<TypeFieldMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.TypeFieldMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TypeFieldMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TypeFieldMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TypeFieldMapping;
    static equals(a: TypeFieldMapping | PlainMessage<TypeFieldMapping> | undefined, b: TypeFieldMapping | PlainMessage<TypeFieldMapping> | undefined): boolean;
}
/**
 * Defines mapping for a single field
 *
 * @generated from message wg.cosmo.node.v1.FieldMapping
 */
export declare class FieldMapping extends Message<FieldMapping> {
    /**
     * Original GraphQL field name
     *
     * @generated from field: string original = 1;
     */
    original: string;
    /**
     * Mapped gRPC field name
     *
     * @generated from field: string mapped = 2;
     */
    mapped: string;
    /**
     * Mappings for field arguments
     *
     * @generated from field: repeated wg.cosmo.node.v1.ArgumentMapping argument_mappings = 3;
     */
    argumentMappings: ArgumentMapping[];
    constructor(data?: PartialMessage<FieldMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.FieldMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FieldMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FieldMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FieldMapping;
    static equals(a: FieldMapping | PlainMessage<FieldMapping> | undefined, b: FieldMapping | PlainMessage<FieldMapping> | undefined): boolean;
}
/**
 * Defines mapping for a field argument
 *
 * @generated from message wg.cosmo.node.v1.ArgumentMapping
 */
export declare class ArgumentMapping extends Message<ArgumentMapping> {
    /**
     * Original GraphQL argument name
     *
     * @generated from field: string original = 1;
     */
    original: string;
    /**
     * Mapped gRPC field name
     *
     * @generated from field: string mapped = 2;
     */
    mapped: string;
    constructor(data?: PartialMessage<ArgumentMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.ArgumentMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ArgumentMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ArgumentMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ArgumentMapping;
    static equals(a: ArgumentMapping | PlainMessage<ArgumentMapping> | undefined, b: ArgumentMapping | PlainMessage<ArgumentMapping> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.EnumMapping
 */
export declare class EnumMapping extends Message<EnumMapping> {
    /**
     * @generated from field: string type = 1;
     */
    type: string;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.EnumValueMapping values = 2;
     */
    values: EnumValueMapping[];
    constructor(data?: PartialMessage<EnumMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.EnumMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EnumMapping;