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 lookup operation
 *
 * @generated from enum wg.cosmo.node.v1.LookupType
 */
export declare enum LookupType {
    /**
     * Unspecified lookup type
     *
     * @generated from enum value: LOOKUP_TYPE_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * Lookup type for field resolution
     *
     * @generated from enum value: LOOKUP_TYPE_RESOLVE = 1;
     */
    RESOLVE = 1,
    /**
     * Lookup type for the @requires directive
     *
     * @generated from enum value: LOOKUP_TYPE_REQUIRES = 2;
     */
    REQUIRES = 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[];
    /**
     * @generated from field: wg.cosmo.node.v1.CostConfiguration cost_configuration = 16;
     */
    costConfiguration?: CostConfiguration;
    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.CostConfiguration
 */
export declare class CostConfiguration extends Message<CostConfiguration> {
    /**
     * @generated from field: repeated wg.cosmo.node.v1.FieldWeightConfiguration field_weights = 1;
     */
    fieldWeights: FieldWeightConfiguration[];
    /**
     * @generated from field: repeated wg.cosmo.node.v1.FieldListSizeConfiguration list_sizes = 2;
     */
    listSizes: FieldListSizeConfiguration[];
    /**
     * @generated from field: map<string, int32> type_weights = 3;
     */
    typeWeights: {
        [key: string]: number;
    };
    /**
     * @generated from field: map<string, int32> directive_argument_weights = 4;
     */
    directiveArgumentWeights: {
        [key: string]: number;
    };
    constructor(data?: PartialMessage<CostConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.CostConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CostConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CostConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CostConfiguration;
    static equals(a: CostConfiguration | PlainMessage<CostConfiguration> | undefined, b: CostConfiguration | PlainMessage<CostConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.FieldWeightConfiguration
 */
export declare class FieldWeightConfiguration extends Message<FieldWeightConfiguration> {
    /**
     * @generated from field: string type_name = 1;
     */
    typeName: string;
    /**
     * @generated from field: string field_name = 2;
     */
    fieldName: string;
    /**
     * @generated from field: optional int32 weight = 3;
     */
    weight?: number;
    /**
     * @generated from field: map<string, int32> argument_weights = 4;
     */
    argumentWeights: {
        [key: string]: number;
    };
    constructor(data?: PartialMessage<FieldWeightConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.FieldWeightConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FieldWeightConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FieldWeightConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FieldWeightConfiguration;
    static equals(a: FieldWeightConfiguration | PlainMessage<FieldWeightConfiguration> | undefined, b: FieldWeightConfiguration | PlainMessage<FieldWeightConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.FieldListSizeConfiguration
 */
export declare class FieldListSizeConfiguration extends Message<FieldListSizeConfiguration> {
    /**
     * @generated from field: string type_name = 1;
     */
    typeName: string;
    /**
     * @generated from field: string field_name = 2;
     */
    fieldName: string;
    /**
     * @generated from field: optional int32 assumed_size = 3;
     */
    assumedSize?: number;
    /**
     * @generated from field: repeated string slicing_arguments = 4;
     */
    slicingArguments: string[];
    /**
     * @generated from field: repeated string sized_fields = 5;
     */
    sizedFields: string[];
    /**
     * @generated from field: optional bool require_one_slicing_argument = 6;
     */
    requireOneSlicingArgument?: boolean;
    constructor(data?: PartialMessage<FieldListSizeConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.FieldListSizeConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FieldListSizeConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FieldListSizeConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FieldListSizeConfiguration;
    static equals(a: FieldListSizeConfiguration | PlainMessage<FieldListSizeConfiguration> | undefined, b: FieldListSizeConfiguration | PlainMessage<FieldListSizeConfiguration> | 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[];
    /**
     * @generated from field: repeated string require_fetch_reasons_field_names = 4;
     */
    requireFetchReasonsFieldNames: 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;
}
/**
 * Defines mapping for a gRPC service
 *
 * @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[];
    /**
     * Mappings for GraphQL resolve operations to gRPC service methods
     *
     * @generated from field: repeated wg.cosmo.node.v1.LookupMapping resolve_mappings = 7;
     */
    resolveMappings: LookupMapping[];
    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 for a lookup operation
 *
 * @generated from message wg.cosmo.node.v1.LookupMapping
 */
export declare class LookupMapping extends Message<LookupMapping> {
    /**
     * Type of lookup operation
     *
     * @generated from field: wg.cosmo.node.v1.LookupType type = 1;
     */
    type: LookupType;
    /**
     * Mappings for GraphQL type fields to gRPC message fields
     *
     * @generated from field: wg.cosmo.node.v1.LookupFieldMapping lookup_mapping = 2;
     */
    lookupMapping?: LookupFieldMapping;
    /**
     * Mapped gRPC method name
     *
     * @generated from field: string rpc = 3;
     */
    rpc: string;
    /**
     * Mapped gRPC request message type name
     *
     * @generated from field: string request = 4;
     */
    request: string;
    /**
     * Mapped gRPC response message type name
     *
     * @generated from field: string response = 5;
     */
    response: string;
    constructor(data?: PartialMessage<LookupMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.LookupMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LookupMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LookupMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LookupMapping;
    static equals(a: LookupMapping | PlainMessage<LookupMapping> | undefined, b: LookupMapping | PlainMessage<LookupMapping> | undefined): boolean;
}
/**
 * Defines mapping for a lookup field
 *
 * @generated from message wg.cosmo.node.v1.LookupFieldMapping
 */
export declare class LookupFieldMapping extends Message<LookupFieldMapping> {
    /**
     * GraphQL type name
     *
     * @generated from field: string type = 1;
     */
    type: string;
    /**
     * Mapping for the lookup field
     *
     * @generated from field: wg.cosmo.node.v1.FieldMapping field_mapping = 2;
     */
    fieldMapping?: FieldMapping;
    constructor(data?: PartialMessage<LookupFieldMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.LookupFieldMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LookupFieldMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LookupFieldMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LookupFieldMapping;
    static equals(a: LookupFieldMapping | PlainMessage<LookupFieldMapping> | undefined, b: LookupFieldMapping | PlainMessage<LookupFieldMapping> | 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;
    /**
     * Mappings for required fields
     *
     * @generated from field: repeated wg.cosmo.node.v1.RequiredFieldMapping required_field_mappings = 7;
     */
    requiredFieldMappings: RequiredFieldMapping[];
    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 for required fields
 *
 * @generated from message wg.cosmo.node.v1.RequiredFieldMapping
 */
export declare class RequiredFieldMapping extends Message<RequiredFieldMapping> {
    /**
     * @generated from field: wg.cosmo.node.v1.FieldMapping field_mapping = 1;
     */
    fieldMapping?: FieldMapping;
    /**
     * Mapped gRPC method name
     *
     * @generated from field: string rpc = 2;
     */
    rpc: string;
    /**
     * gRPC request message type name
     *
     * @generated from field: string request = 3;
     */
    request: string;
    /**
     * gRPC response message type name
     *
     * @generated from field: string response = 4;
     */
    response: string;
    constructor(data?: PartialMessage<RequiredFieldMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.RequiredFieldMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequiredFieldMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequiredFieldMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequiredFieldMapping;
    static equals(a: RequiredFieldMapping | PlainMessage<RequiredFieldMapping> | undefined, b: RequiredFieldMapping | PlainMessage<RequiredFieldMapping> | 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;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EnumMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EnumMapping;
    static equals(a: EnumMapping | PlainMessage<EnumMapping> | undefined, b: EnumMapping | PlainMessage<EnumMapping> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.EnumValueMapping
 */
export declare class EnumValueMapping extends Message<EnumValueMapping> {
    /**
     * @generated from field: string original = 1;
     */
    original: string;
    /**
     * @generated from field: string mapped = 2;
     */
    mapped: string;
    constructor(data?: PartialMessage<EnumValueMapping>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.EnumValueMapping";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EnumValueMapping;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EnumValueMapping;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EnumValueMapping;
    static equals(a: EnumValueMapping | PlainMessage<EnumValueMapping> | undefined, b: EnumValueMapping | PlainMessage<EnumValueMapping> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.NatsStreamConfiguration
 */
export declare class NatsStreamConfiguration extends Message<NatsStreamConfiguration> {
    /**
     * @generated from field: string consumer_name = 1;
     */
    consumerName: string;
    /**
     * @generated from field: string stream_name = 2;
     */
    streamName: string;
    /**
     * @generated from field: int32 consumer_inactive_threshold = 3;
     */
    consumerInactiveThreshold: number;
    constructor(data?: PartialMessage<NatsStreamConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.NatsStreamConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NatsStreamConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NatsStreamConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NatsStreamConfiguration;
    static equals(a: NatsStreamConfiguration | PlainMessage<NatsStreamConfiguration> | undefined, b: NatsStreamConfiguration | PlainMessage<NatsStreamConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.NatsEventConfiguration
 */
export declare class NatsEventConfiguration extends Message<NatsEventConfiguration> {
    /**
     * @generated from field: wg.cosmo.node.v1.EngineEventConfiguration engine_event_configuration = 1;
     */
    engineEventConfiguration?: EngineEventConfiguration;
    /**
     * @generated from field: repeated string subjects = 2;
     */
    subjects: string[];
    /**
     * @generated from field: wg.cosmo.node.v1.NatsStreamConfiguration stream_configuration = 3;
     */
    streamConfiguration?: NatsStreamConfiguration;
    constructor(data?: PartialMessage<NatsEventConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.NatsEventConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NatsEventConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NatsEventConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NatsEventConfiguration;
    static equals(a: NatsEventConfiguration | PlainMessage<NatsEventConfiguration> | undefined, b: NatsEventConfiguration | PlainMessage<NatsEventConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.KafkaEventConfiguration
 */
export declare class KafkaEventConfiguration extends Message<KafkaEventConfiguration> {
    /**
     * @generated from field: wg.cosmo.node.v1.EngineEventConfiguration engine_event_configuration = 1;
     */
    engineEventConfiguration?: EngineEventConfiguration;
    /**
     * @generated from field: repeated string topics = 2;
     */
    topics: string[];
    constructor(data?: PartialMessage<KafkaEventConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.KafkaEventConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): KafkaEventConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): KafkaEventConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): KafkaEventConfiguration;
    static equals(a: KafkaEventConfiguration | PlainMessage<KafkaEventConfiguration> | undefined, b: KafkaEventConfiguration | PlainMessage<KafkaEventConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.RedisEventConfiguration
 */
export declare class RedisEventConfiguration extends Message<RedisEventConfiguration> {
    /**
     * @generated from field: wg.cosmo.node.v1.EngineEventConfiguration engine_event_configuration = 1;
     */
    engineEventConfiguration?: EngineEventConfiguration;
    /**
     * @generated from field: repeated string channels = 2;
     */
    channels: string[];
    constructor(data?: PartialMessage<RedisEventConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.RedisEventConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RedisEventConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RedisEventConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RedisEventConfiguration;
    static equals(a: RedisEventConfiguration | PlainMessage<RedisEventConfiguration> | undefined, b: RedisEventConfiguration | PlainMessage<RedisEventConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.EngineEventConfiguration
 */
export declare class EngineEventConfiguration extends Message<EngineEventConfiguration> {
    /**
     * @generated from field: string provider_id = 1;
     */
    providerId: string;
    /**
     * @generated from field: wg.cosmo.node.v1.EventType type = 2;
     */
    type: EventType;
    /**
     * @generated from field: string type_name = 3;
     */
    typeName: string;
    /**
     * @generated from field: string field_name = 4;
     */
    fieldName: string;
    constructor(data?: PartialMessage<EngineEventConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.EngineEventConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EngineEventConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EngineEventConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EngineEventConfiguration;
    static equals(a: EngineEventConfiguration | PlainMessage<EngineEventConfiguration> | undefined, b: EngineEventConfiguration | PlainMessage<EngineEventConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.DataSourceCustomEvents
 */
export declare class DataSourceCustomEvents extends Message<DataSourceCustomEvents> {
    /**
     * @generated from field: repeated wg.cosmo.node.v1.NatsEventConfiguration nats = 1;
     */
    nats: NatsEventConfiguration[];
    /**
     * @generated from field: repeated wg.cosmo.node.v1.KafkaEventConfiguration kafka = 2;
     */
    kafka: KafkaEventConfiguration[];
    /**
     * @generated from field: repeated wg.cosmo.node.v1.RedisEventConfiguration redis = 3;
     */
    redis: RedisEventConfiguration[];
    constructor(data?: PartialMessage<DataSourceCustomEvents>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.DataSourceCustomEvents";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataSourceCustomEvents;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataSourceCustomEvents;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataSourceCustomEvents;
    static equals(a: DataSourceCustomEvents | PlainMessage<DataSourceCustomEvents> | undefined, b: DataSourceCustomEvents | PlainMessage<DataSourceCustomEvents> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.DataSourceCustom_Static
 */
export declare class DataSourceCustom_Static extends Message<DataSourceCustom_Static> {
    /**
     * @generated from field: wg.cosmo.node.v1.ConfigurationVariable data = 1;
     */
    data?: ConfigurationVariable;
    constructor(data?: PartialMessage<DataSourceCustom_Static>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.DataSourceCustom_Static";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataSourceCustom_Static;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataSourceCustom_Static;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataSourceCustom_Static;
    static equals(a: DataSourceCustom_Static | PlainMessage<DataSourceCustom_Static> | undefined, b: DataSourceCustom_Static | PlainMessage<DataSourceCustom_Static> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.ConfigurationVariable
 */
export declare class ConfigurationVariable extends Message<ConfigurationVariable> {
    /**
     * @generated from field: wg.cosmo.node.v1.ConfigurationVariableKind kind = 1;
     */
    kind: ConfigurationVariableKind;
    /**
     * @generated from field: string static_variable_content = 2;
     */
    staticVariableContent: string;
    /**
     * @generated from field: string environment_variable_name = 3;
     */
    environmentVariableName: string;
    /**
     * @generated from field: string environment_variable_default_value = 4;
     */
    environmentVariableDefaultValue: string;
    /**
     * @generated from field: string placeholder_variable_name = 5;
     */
    placeholderVariableName: string;
    constructor(data?: PartialMessage<ConfigurationVariable>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.ConfigurationVariable";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConfigurationVariable;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConfigurationVariable;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConfigurationVariable;
    static equals(a: ConfigurationVariable | PlainMessage<ConfigurationVariable> | undefined, b: ConfigurationVariable | PlainMessage<ConfigurationVariable> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.DirectiveConfiguration
 */
export declare class DirectiveConfiguration extends Message<DirectiveConfiguration> {
    /**
     * @generated from field: string directive_name = 1;
     */
    directiveName: string;
    /**
     * @generated from field: string rename_to = 2;
     */
    renameTo: string;
    constructor(data?: PartialMessage<DirectiveConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.DirectiveConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DirectiveConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DirectiveConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DirectiveConfiguration;
    static equals(a: DirectiveConfiguration | PlainMessage<DirectiveConfiguration> | undefined, b: DirectiveConfiguration | PlainMessage<DirectiveConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.URLQueryConfiguration
 */
export declare class URLQueryConfiguration extends Message<URLQueryConfiguration> {
    /**
     * @generated from field: string name = 1;
     */
    name: string;
    /**
     * @generated from field: string value = 2;
     */
    value: string;
    constructor(data?: PartialMessage<URLQueryConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.URLQueryConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): URLQueryConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): URLQueryConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): URLQueryConfiguration;
    static equals(a: URLQueryConfiguration | PlainMessage<URLQueryConfiguration> | undefined, b: URLQueryConfiguration | PlainMessage<URLQueryConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.HTTPHeader
 */
export declare class HTTPHeader extends Message<HTTPHeader> {
    /**
     * @generated from field: repeated wg.cosmo.node.v1.ConfigurationVariable values = 1;
     */
    values: ConfigurationVariable[];
    constructor(data?: PartialMessage<HTTPHeader>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.HTTPHeader";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HTTPHeader;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HTTPHeader;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HTTPHeader;
    static equals(a: HTTPHeader | PlainMessage<HTTPHeader> | undefined, b: HTTPHeader | PlainMessage<HTTPHeader> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.MTLSConfiguration
 */
export declare class MTLSConfiguration extends Message<MTLSConfiguration> {
    /**
     * @generated from field: wg.cosmo.node.v1.ConfigurationVariable key = 1;
     */
    key?: ConfigurationVariable;
    /**
     * @generated from field: wg.cosmo.node.v1.ConfigurationVariable cert = 2;
     */
    cert?: ConfigurationVariable;
    /**
     * @generated from field: bool insecureSkipVerify = 3;
     */
    insecureSkipVerify: boolean;
    constructor(data?: PartialMessage<MTLSConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.MTLSConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MTLSConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MTLSConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MTLSConfiguration;
    static equals(a: MTLSConfiguration | PlainMessage<MTLSConfiguration> | undefined, b: MTLSConfiguration | PlainMessage<MTLSConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.GraphQLSubscriptionConfiguration
 */
export declare class GraphQLSubscriptionConfiguration extends Message<GraphQLSubscriptionConfiguration> {
    /**
     * @generated from field: bool enabled = 1;
     */
    enabled: boolean;
    /**
     * @generated from field: wg.cosmo.node.v1.ConfigurationVariable url = 2;
     */
    url?: ConfigurationVariable;
    /**
     * @deprecated - Kept for backwards compatibility when decoding. Use protocol instead.
     *
     * @generated from field: optional bool useSSE = 3;
     */
    useSSE?: boolean;
    /**
     * @generated from field: optional wg.cosmo.common.GraphQLSubscriptionProtocol protocol = 4;
     */
    protocol?: GraphQLSubscriptionProtocol;
    /**
     * @generated from field: optional wg.cosmo.common.GraphQLWebsocketSubprotocol websocketSubprotocol = 5;
     */
    websocketSubprotocol?: GraphQLWebsocketSubprotocol;
    constructor(data?: PartialMessage<GraphQLSubscriptionConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.GraphQLSubscriptionConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GraphQLSubscriptionConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GraphQLSubscriptionConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GraphQLSubscriptionConfiguration;
    static equals(a: GraphQLSubscriptionConfiguration | PlainMessage<GraphQLSubscriptionConfiguration> | undefined, b: GraphQLSubscriptionConfiguration | PlainMessage<GraphQLSubscriptionConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.GraphQLFederationConfiguration
 */
export declare class GraphQLFederationConfiguration extends Message<GraphQLFederationConfiguration> {
    /**
     * @generated from field: bool enabled = 1;
     */
    enabled: boolean;
    /**
     * @generated from field: string serviceSdl = 2;
     */
    serviceSdl: string;
    constructor(data?: PartialMessage<GraphQLFederationConfiguration>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.GraphQLFederationConfiguration";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GraphQLFederationConfiguration;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GraphQLFederationConfiguration;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GraphQLFederationConfiguration;
    static equals(a: GraphQLFederationConfiguration | PlainMessage<GraphQLFederationConfiguration> | undefined, b: GraphQLFederationConfiguration | PlainMessage<GraphQLFederationConfiguration> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.InternedString
 */
export declare class InternedString extends Message<InternedString> {
    /**
     * key to index into EngineConfiguration.stringStorage
     *
     * @generated from field: string key = 1;
     */
    key: string;
    constructor(data?: PartialMessage<InternedString>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.InternedString";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InternedString;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InternedString;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InternedString;
    static equals(a: InternedString | PlainMessage<InternedString> | undefined, b: InternedString | PlainMessage<InternedString> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.SingleTypeField
 */
export declare class SingleTypeField extends Message<SingleTypeField> {
    /**
     * @generated from field: string type_name = 1;
     */
    typeName: string;
    /**
     * @generated from field: string field_name = 2;
     */
    fieldName: string;
    constructor(data?: PartialMessage<SingleTypeField>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.SingleTypeField";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SingleTypeField;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SingleTypeField;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SingleTypeField;
    static equals(a: SingleTypeField | PlainMessage<SingleTypeField> | undefined, b: SingleTypeField | PlainMessage<SingleTypeField> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.SubscriptionFieldCondition
 */
export declare class SubscriptionFieldCondition extends Message<SubscriptionFieldCondition> {
    /**
     * @generated from field: repeated string field_path = 1;
     */
    fieldPath: string[];
    /**
     * @generated from field: string json = 2;
     */
    json: string;
    constructor(data?: PartialMessage<SubscriptionFieldCondition>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.SubscriptionFieldCondition";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionFieldCondition;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionFieldCondition;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionFieldCondition;
    static equals(a: SubscriptionFieldCondition | PlainMessage<SubscriptionFieldCondition> | undefined, b: SubscriptionFieldCondition | PlainMessage<SubscriptionFieldCondition> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.SubscriptionFilterCondition
 */
export declare class SubscriptionFilterCondition extends Message<SubscriptionFilterCondition> {
    /**
     * @generated from field: repeated wg.cosmo.node.v1.SubscriptionFilterCondition and = 1;
     */
    and: SubscriptionFilterCondition[];
    /**
     * @generated from field: optional wg.cosmo.node.v1.SubscriptionFieldCondition in = 2;
     */
    in?: SubscriptionFieldCondition;
    /**
     * @generated from field: optional wg.cosmo.node.v1.SubscriptionFilterCondition not = 3;
     */
    not?: SubscriptionFilterCondition;
    /**
     * @generated from field: repeated wg.cosmo.node.v1.SubscriptionFilterCondition or = 4;
     */
    or: SubscriptionFilterCondition[];
    constructor(data?: PartialMessage<SubscriptionFilterCondition>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.SubscriptionFilterCondition";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionFilterCondition;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionFilterCondition;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionFilterCondition;
    static equals(a: SubscriptionFilterCondition | PlainMessage<SubscriptionFilterCondition> | undefined, b: SubscriptionFilterCondition | PlainMessage<SubscriptionFilterCondition> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.CacheWarmerOperations
 */
export declare class CacheWarmerOperations extends Message<CacheWarmerOperations> {
    /**
     * @generated from field: repeated wg.cosmo.node.v1.Operation operations = 1;
     */
    operations: Operation[];
    constructor(data?: PartialMessage<CacheWarmerOperations>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.CacheWarmerOperations";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CacheWarmerOperations;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CacheWarmerOperations;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CacheWarmerOperations;
    static equals(a: CacheWarmerOperations | PlainMessage<CacheWarmerOperations> | undefined, b: CacheWarmerOperations | PlainMessage<CacheWarmerOperations> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.Operation
 */
export declare class Operation extends Message<Operation> {
    /**
     * @generated from field: wg.cosmo.node.v1.OperationRequest request = 1;
     */
    request?: OperationRequest;
    /**
     * @generated from field: wg.cosmo.node.v1.ClientInfo client = 2;
     */
    client?: ClientInfo;
    constructor(data?: PartialMessage<Operation>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.Operation";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Operation;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Operation;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Operation;
    static equals(a: Operation | PlainMessage<Operation> | undefined, b: Operation | PlainMessage<Operation> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.OperationRequest
 */
export declare class OperationRequest extends Message<OperationRequest> {
    /**
     * @generated from field: string operation_name = 1;
     */
    operationName: string;
    /**
     * @generated from field: string query = 2;
     */
    query: string;
    /**
     * @generated from field: wg.cosmo.node.v1.Extension extensions = 3;
     */
    extensions?: Extension;
    constructor(data?: PartialMessage<OperationRequest>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.OperationRequest";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OperationRequest;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OperationRequest;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OperationRequest;
    static equals(a: OperationRequest | PlainMessage<OperationRequest> | undefined, b: OperationRequest | PlainMessage<OperationRequest> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.Extension
 */
export declare class Extension extends Message<Extension> {
    /**
     * @generated from field: wg.cosmo.node.v1.PersistedQuery persisted_query = 1;
     */
    persistedQuery?: PersistedQuery;
    constructor(data?: PartialMessage<Extension>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.Extension";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Extension;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Extension;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Extension;
    static equals(a: Extension | PlainMessage<Extension> | undefined, b: Extension | PlainMessage<Extension> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.PersistedQuery
 */
export declare class PersistedQuery extends Message<PersistedQuery> {
    /**
     * @generated from field: string sha256_hash = 1;
     */
    sha256Hash: string;
    /**
     * @generated from field: int32 version = 2;
     */
    version: number;
    constructor(data?: PartialMessage<PersistedQuery>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.PersistedQuery";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PersistedQuery;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PersistedQuery;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PersistedQuery;
    static equals(a: PersistedQuery | PlainMessage<PersistedQuery> | undefined, b: PersistedQuery | PlainMessage<PersistedQuery> | undefined): boolean;
}
/**
 * @generated from message wg.cosmo.node.v1.ClientInfo
 */
export declare class ClientInfo extends Message<ClientInfo> {
    /**
     * @generated from field: string name = 1;
     */
    name: string;
    /**
     * @generated from field: string version = 2;
     */
    version: string;
    constructor(data?: PartialMessage<ClientInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "wg.cosmo.node.v1.ClientInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientInfo;
    static equals(a: ClientInfo | PlainMessage<ClientInfo> | undefined, b: ClientInfo | PlainMessage<ClientInfo> | undefined): boolean;
}