import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import Long from "long";
import type { CallContext, CallOptions } from "nice-grpc-common";
import { Timestamp } from "./google/protobuf/timestamp";
export declare const protobufPackage = "tfplugin6";
/**
 * Terraform Plugin RPC protocol version 6.11
 *
 * This file defines version 6.11 of the RPC protocol. To implement a plugin
 * against this protocol, copy this definition into your own codebase and
 * use protoc to generate stubs for your target language.
 *
 * Any minor versions of protocol 6 to follow should modify this file while
 * maintaining backwards compatibility. Breaking changes, if any are required,
 * will come in a subsequent major version with its own separate proto definition.
 *
 * Note that only the proto files included in a release tag of Terraform are
 * official protocol releases. Proto files taken from other commits may include
 * incomplete changes or features that did not make it into a final release.
 * In all reasonable cases, plugin developers should take the proto file from
 * the tag of the most recent release of Terraform, and not from the main
 * branch or any other development branch.
 */
export declare enum StringKind {
    PLAIN = 0,
    MARKDOWN = 1,
    UNRECOGNIZED = -1
}
export declare function stringKindFromJSON(object: any): StringKind;
export declare function stringKindToJSON(object: StringKind): string;
/**
 * DynamicValue is an opaque encoding of terraform data, with the field name
 * indicating the encoding scheme used.
 */
export interface DynamicValue {
    msgpack: Uint8Array;
    json: Uint8Array;
}
export interface Diagnostic {
    severity: Diagnostic_Severity;
    summary: string;
    detail: string;
    attribute: AttributePath | undefined;
}
export declare enum Diagnostic_Severity {
    INVALID = 0,
    ERROR = 1,
    WARNING = 2,
    UNRECOGNIZED = -1
}
export declare function diagnostic_SeverityFromJSON(object: any): Diagnostic_Severity;
export declare function diagnostic_SeverityToJSON(object: Diagnostic_Severity): string;
export interface FunctionError {
    text: string;
    /**
     * The optional function_argument records the index position of the
     * argument which caused the error.
     */
    functionArgument?: Long | undefined;
}
export interface AttributePath {
    steps: AttributePath_Step[];
}
export interface AttributePath_Step {
    /**
     * Set "attribute_name" to represent looking up an attribute
     * in the current object value.
     */
    attributeName?: string | undefined;
    /**
     * Set "element_key_*" to represent looking up an element in
     * an indexable collection type.
     */
    elementKeyString?: string | undefined;
    elementKeyInt?: Long | undefined;
}
export interface StopProvider {
}
export interface StopProvider_Request {
}
export interface StopProvider_Response {
    Error: string;
}
/**
 * RawState holds the stored state for a resource to be upgraded by the
 * provider. It can be in one of two formats, the current json encoded format
 * in bytes, or the legacy flatmap format as a map of strings.
 */
export interface RawState {
    json: Uint8Array;
    flatmap: {
        [key: string]: string;
    };
}
export interface RawState_FlatmapEntry {
    key: string;
    value: string;
}
/**
 * ResourceIdentitySchema represents the structure and types of data used to identify
 * a managed resource type. Effectively, resource identity is a versioned object
 * that can be used to compare resources, whether already managed and/or being
 * discovered.
 */
export interface ResourceIdentitySchema {
    /**
     * version is the identity version and separate from the Schema version.
     * Any time the structure or format of identity_attributes changes, this version
     * should be incremented. Versioning implicitly starts at 0 and by convention
     * should be incremented by 1 each change.
     *
     * When comparing identity_attributes data, differing versions should always be treated
     * as inequal.
     */
    version: Long;
    /**
     * identity_attributes are the individual value definitions which define identity data
     * for a managed resource type. This information is used to decode DynamicValue of
     * identity data.
     *
     * These attributes are intended for permanent identity data and must be wholly
     * representative of all data necessary to compare two managed resource instances
     * with no other data. This generally should include account, endpoint, location,
     * and automatically generated identifiers. For some resources, this may include
     * configuration-based data, such as a required name which must be unique.
     */
    identityAttributes: ResourceIdentitySchema_IdentityAttribute[];
}
/**
 * IdentityAttribute represents one value of data within resource identity. These
 * are always used in resource identity comparisons.
 */
export interface ResourceIdentitySchema_IdentityAttribute {
    /** name is the identity attribute name */
    name: string;
    /** type is the identity attribute type */
    type: Uint8Array;
    /**
     * required_for_import when enabled signifies that this attribute must be
     * defined for ImportResourceState to complete successfully
     */
    requiredForImport: boolean;
    /**
     * optional_for_import when enabled signifies that this attribute is not
     * required for ImportResourceState, because it can be supplied by the
     * provider. It is still possible to supply this attribute during import.
     */
    optionalForImport: boolean;
    /** description is a human-readable description of the attribute in Markdown */
    description: string;
}
export interface ResourceIdentityData {
    /**
     * identity_data is the resource identity data for the given definition. It should
     * be decoded using the identity schema.
     *
     * This data is considered permanent for the identity version and suitable for
     * longer-term storage.
     */
    identityData: DynamicValue | undefined;
}
/** ActionSchema defines the schema for an action that can be invoked by Terraform. */
export interface ActionSchema {
    /** of the action itself */
    schema: Schema | undefined;
}
/** Schema is the configuration schema for a Resource or Provider. */
export interface Schema {
    /**
     * The version of the schema.
     * Schemas are versioned, so that providers can upgrade a saved resource
     * state when the schema is changed.
     */
    version: Long;
    /** Block is the top level configuration block for this schema. */
    block: Schema_Block | undefined;
}
export interface Schema_Block {
    version: Long;
    attributes: Schema_Attribute[];
    blockTypes: Schema_NestedBlock[];
    description: string;
    descriptionKind: StringKind;
    deprecated: boolean;
    deprecationMessage: string;
    computed: boolean;
}
export interface Schema_Attribute {
    name: string;
    type: Uint8Array;
    nestedType: Schema_Object | undefined;
    description: string;
    required: boolean;
    optional: boolean;
    computed: boolean;
    sensitive: boolean;
    descriptionKind: StringKind;
    deprecated: boolean;
    writeOnly: boolean;
    deprecationMessage: string;
}
export interface Schema_NestedBlock {
    typeName: string;
    block: Schema_Block | undefined;
    nesting: Schema_NestedBlock_NestingMode;
    minItems: Long;
    maxItems: Long;
}
export declare enum Schema_NestedBlock_NestingMode {
    INVALID = 0,
    SINGLE = 1,
    LIST = 2,
    SET = 3,
    MAP = 4,
    GROUP = 5,
    UNRECOGNIZED = -1
}
export declare function schema_NestedBlock_NestingModeFromJSON(object: any): Schema_NestedBlock_NestingMode;
export declare function schema_NestedBlock_NestingModeToJSON(object: Schema_NestedBlock_NestingMode): string;
export interface Schema_Object {
    attributes: Schema_Attribute[];
    nesting: Schema_Object_NestingMode;
    /**
     * MinItems and MaxItems were never used in the protocol, and have no
     * effect on validation.
     *
     * @deprecated
     */
    minItems: Long;
    /** @deprecated */
    maxItems: Long;
}
export declare enum Schema_Object_NestingMode {
    INVALID = 0,
    SINGLE = 1,
    LIST = 2,
    SET = 3,
    MAP = 4,
    UNRECOGNIZED = -1
}
export declare function schema_Object_NestingModeFromJSON(object: any): Schema_Object_NestingMode;
export declare function schema_Object_NestingModeToJSON(object: Schema_Object_NestingMode): string;
export interface FunctionMessage {
    /** parameters is the ordered list of positional function parameters. */
    parameters: Function_Parameter[];
    /**
     * variadic_parameter is an optional final parameter which accepts
     * zero or more argument values, in which Terraform will send an
     * ordered list of the parameter type.
     */
    variadicParameter: Function_Parameter | undefined;
    /** Return is the function return parameter. */
    return: Function_Return | undefined;
    /** summary is the human-readable shortened documentation for the function. */
    summary: string;
    /** description is human-readable documentation for the function. */
    description: string;
    /** description_kind is the formatting of the description. */
    descriptionKind: StringKind;
    /**
     * deprecation_message is human-readable documentation if the
     * function is deprecated.
     */
    deprecationMessage: string;
}
export interface Function_Parameter {
    /** name is the human-readable display name for the parameter. */
    name: string;
    /** type is the type constraint for the parameter. */
    type: Uint8Array;
    /**
     * allow_null_value when enabled denotes that a null argument value can
     * be passed to the provider. When disabled, Terraform returns an error
     * if the argument value is null.
     */
    allowNullValue: boolean;
    /**
     * allow_unknown_values when enabled denotes that only wholly known
     * argument values will be passed to the provider. When disabled,
     * Terraform skips the function call entirely and assumes an unknown
     * value result from the function.
     */
    allowUnknownValues: boolean;
    /** description is human-readable documentation for the parameter. */
    description: string;
    /** description_kind is the formatting of the description. */
    descriptionKind: StringKind;
}
export interface Function_Return {
    /** type is the type constraint for the function result. */
    type: Uint8Array;
}
/**
 * ServerCapabilities allows providers to communicate extra information
 * regarding supported protocol features. This is used to indicate
 * availability of certain forward-compatible changes which may be optional
 * in a major protocol version, but cannot be tested for directly.
 */
export interface ServerCapabilities {
    /**
     * The plan_destroy capability signals that a provider expects a call
     * to PlanResourceChange when a resource is going to be destroyed.
     */
    planDestroy: boolean;
    /**
     * The get_provider_schema_optional capability indicates that this
     * provider does not require calling GetProviderSchema to operate
     * normally, and the caller can used a cached copy of the provider's
     * schema.
     */
    getProviderSchemaOptional: boolean;
    /**
     * The move_resource_state capability signals that a provider supports the
     * MoveResourceState RPC.
     */
    moveResourceState: boolean;
    /**
     * The generate_resource_config capability signals that a provider supports
     * GenerateResourceConfig.
     */
    generateResourceConfig: boolean;
}
/**
 * ClientCapabilities allows Terraform to publish information regarding
 * supported protocol features. This is used to indicate availability of
 * certain forward-compatible changes which may be optional in a major
 * protocol version, but cannot be tested for directly.
 */
export interface ClientCapabilities {
    /**
     * The deferral_allowed capability signals that the client is able to
     * handle deferred responses from the provider.
     */
    deferralAllowed: boolean;
    /**
     * The write_only_attributes_allowed capability signals that the client
     * is able to handle write_only attributes for managed resources.
     */
    writeOnlyAttributesAllowed: boolean;
    /**
     * store_planned_private indicates that the client will store the private data
     * returned with an initial plan, and send it back to the provider as
     * PlannedPrivate data in a subsequent plan request.
     */
    storePlannedPrivate: boolean;
    /**
     * computed_blocks_allowed indicates that the client can handle optionally
     * computed nested block values in resources. Because older versions of
     * Terraform without this capability will ignore the computed flag in the
     * schema, it is up to the provider to return an appropriate diagnostic when
     * a resource requiring the computed behavior is used.
     */
    computedBlocksAllowed: boolean;
}
/** Deferred is a message that indicates that change is deferred for a reason. */
export interface Deferred {
    /** reason is the reason for deferring the change. */
    reason: Deferred_Reason;
}
/** Reason is the reason for deferring the change. */
export declare enum Deferred_Reason {
    /** UNKNOWN - UNKNOWN is the default value, and should not be used. */
    UNKNOWN = 0,
    /**
     * RESOURCE_CONFIG_UNKNOWN - RESOURCE_CONFIG_UNKNOWN is used when the config is partially unknown and the real
     * values need to be known before the change can be planned.
     */
    RESOURCE_CONFIG_UNKNOWN = 1,
    /**
     * PROVIDER_CONFIG_UNKNOWN - PROVIDER_CONFIG_UNKNOWN is used when parts of the provider configuration
     * are unknown, e.g. the provider configuration is only known after the apply is done.
     */
    PROVIDER_CONFIG_UNKNOWN = 2,
    /** ABSENT_PREREQ - ABSENT_PREREQ is used when a hard dependency has not been satisfied. */
    ABSENT_PREREQ = 3,
    UNRECOGNIZED = -1
}
export declare function deferred_ReasonFromJSON(object: any): Deferred_Reason;
export declare function deferred_ReasonToJSON(object: Deferred_Reason): string;
export interface GetMetadata {
}
export interface GetMetadata_Request {
}
export interface GetMetadata_Response {
    serverCapabilities: ServerCapabilities | undefined;
    diagnostics: Diagnostic[];
    dataSources: GetMetadata_DataSourceMetadata[];
    resources: GetMetadata_ResourceMetadata[];
    /** functions returns metadata for any functions. */
    functions: GetMetadata_FunctionMetadata[];
    ephemeralResources: GetMetadata_EphemeralMetadata[];
    listResources: GetMetadata_ListResourceMetadata[];
    stateStores: GetMetadata_StateStoreMetadata[];
    actions: GetMetadata_ActionMetadata[];
}
export interface GetMetadata_EphemeralMetadata {
    typeName: string;
}
export interface GetMetadata_FunctionMetadata {
    /** name is the function name. */
    name: string;
}
export interface GetMetadata_DataSourceMetadata {
    typeName: string;
}
export interface GetMetadata_ResourceMetadata {
    typeName: string;
}
export interface GetMetadata_ListResourceMetadata {
    typeName: string;
}
export interface GetMetadata_StateStoreMetadata {
    typeName: string;
}
export interface GetMetadata_ActionMetadata {
    typeName: string;
}
export interface GetProviderSchema {
}
export interface GetProviderSchema_Request {
}
export interface GetProviderSchema_Response {
    provider: Schema | undefined;
    resourceSchemas: {
        [key: string]: Schema;
    };
    dataSourceSchemas: {
        [key: string]: Schema;
    };
    functions: {
        [key: string]: FunctionMessage;
    };
    ephemeralResourceSchemas: {
        [key: string]: Schema;
    };
    listResourceSchemas: {
        [key: string]: Schema;
    };
    stateStoreSchemas: {
        [key: string]: Schema;
    };
    actionSchemas: {
        [key: string]: ActionSchema;
    };
    diagnostics: Diagnostic[];
    providerMeta: Schema | undefined;
    serverCapabilities: ServerCapabilities | undefined;
}
export interface GetProviderSchema_Response_ResourceSchemasEntry {
    key: string;
    value: Schema | undefined;
}
export interface GetProviderSchema_Response_DataSourceSchemasEntry {
    key: string;
    value: Schema | undefined;
}
export interface GetProviderSchema_Response_FunctionsEntry {
    key: string;
    value: FunctionMessage | undefined;
}
export interface GetProviderSchema_Response_EphemeralResourceSchemasEntry {
    key: string;
    value: Schema | undefined;
}
export interface GetProviderSchema_Response_ListResourceSchemasEntry {
    key: string;
    value: Schema | undefined;
}
export interface GetProviderSchema_Response_StateStoreSchemasEntry {
    key: string;
    value: Schema | undefined;
}
export interface GetProviderSchema_Response_ActionSchemasEntry {
    key: string;
    value: ActionSchema | undefined;
}
export interface ValidateProviderConfig {
}
export interface ValidateProviderConfig_Request {
    config: DynamicValue | undefined;
}
export interface ValidateProviderConfig_Response {
    diagnostics: Diagnostic[];
}
export interface UpgradeResourceState {
}
/**
 * Request is the message that is sent to the provider during the
 * UpgradeResourceState RPC.
 *
 * This message intentionally does not include configuration data as any
 * configuration-based or configuration-conditional changes should occur
 * during the PlanResourceChange RPC. Additionally, the configuration is
 * not guaranteed to exist (in the case of resource destruction), be wholly
 * known, nor match the given prior state, which could lead to unexpected
 * provider behaviors for practitioners.
 */
export interface UpgradeResourceState_Request {
    typeName: string;
    /** version is the schema_version number recorded in the state file */
    version: Long;
    /**
     * raw_state is the raw states as stored for the resource.  Core does
     * not have access to the schema of prior_version, so it's the
     * provider's responsibility to interpret this value using the
     * appropriate older schema. The raw_state will be the json encoded
     * state, or a legacy flat-mapped format.
     */
    rawState: RawState | undefined;
}
export interface UpgradeResourceState_Response {
    /**
     * new_state is a msgpack-encoded data structure that, when interpreted with
     * the _current_ schema for this resource type, is functionally equivalent to
     * that which was given in prior_state_raw.
     */
    upgradedState: DynamicValue | undefined;
    /**
     * diagnostics describes any errors encountered during migration that could not
     * be safely resolved, and warnings about any possibly-risky assumptions made
     * in the upgrade process.
     */
    diagnostics: Diagnostic[];
}
export interface GetResourceIdentitySchemas {
}
export interface GetResourceIdentitySchemas_Request {
}
export interface GetResourceIdentitySchemas_Response {
    /** identity_schemas is a mapping of resource type names to their identity schemas. */
    identitySchemas: {
        [key: string]: ResourceIdentitySchema;
    };
    /** diagnostics is the collection of warning and error diagnostics for this request. */
    diagnostics: Diagnostic[];
}
export interface GetResourceIdentitySchemas_Response_IdentitySchemasEntry {
    key: string;
    value: ResourceIdentitySchema | undefined;
}
export interface UpgradeResourceIdentity {
}
export interface UpgradeResourceIdentity_Request {
    /** type_name is the managed resource type name */
    typeName: string;
    /** version is the version of the resource identity data to upgrade */
    version: Long;
    /**
     * raw_identity is the raw identity as stored for the resource. Core does
     * not have access to the identity schema of prior_version, so it's the
     * provider's responsibility to interpret this value using the
     * appropriate older schema. The raw_identity will be json encoded.
     */
    rawIdentity: RawState | undefined;
}
export interface UpgradeResourceIdentity_Response {
    /** upgraded_identity returns the upgraded resource identity data */
    upgradedIdentity: ResourceIdentityData | undefined;
    /** diagnostics is the collection of warning and error diagnostics for this request */
    diagnostics: Diagnostic[];
}
export interface ValidateResourceConfig {
}
export interface ValidateResourceConfig_Request {
    typeName: string;
    config: DynamicValue | undefined;
    clientCapabilities: ClientCapabilities | undefined;
}
export interface ValidateResourceConfig_Response {
    diagnostics: Diagnostic[];
}
export interface ValidateDataResourceConfig {
}
export interface ValidateDataResourceConfig_Request {
    typeName: string;
    config: DynamicValue | undefined;
}
export interface ValidateDataResourceConfig_Response {
    diagnostics: Diagnostic[];
}
export interface ValidateEphemeralResourceConfig {
}
export interface ValidateEphemeralResourceConfig_Request {
    typeName: string;
    config: DynamicValue | undefined;
}
export interface ValidateEphemeralResourceConfig_Response {
    diagnostics: Diagnostic[];
}
export interface ConfigureProvider {
}
export interface ConfigureProvider_Request {
    terraformVersion: string;
    config: DynamicValue | undefined;
    clientCapabilities: ClientCapabilities | undefined;
}
export interface ConfigureProvider_Response {
    diagnostics: Diagnostic[];
}
export interface ReadResource {
}
/**
 * Request is the message that is sent to the provider during the
 * ReadResource RPC.
 *
 * This message intentionally does not include configuration data as any
 * configuration-based or configuration-conditional changes should occur
 * during the PlanResourceChange RPC. Additionally, the configuration is
 * not guaranteed to be wholly known nor match the given prior state, which
 * could lead to unexpected provider behaviors for practitioners.
 */
export interface ReadResource_Request {
    typeName: string;
    currentState: DynamicValue | undefined;
    private: Uint8Array;
    providerMeta: DynamicValue | undefined;
    clientCapabilities: ClientCapabilities | undefined;
    currentIdentity: ResourceIdentityData | undefined;
}
export interface ReadResource_Response {
    newState: DynamicValue | undefined;
    diagnostics: Diagnostic[];
    private: Uint8Array;
    /**
     * deferred is set if the provider is deferring the change. If set the caller
     * needs to handle the deferral.
     */
    deferred: Deferred | undefined;
    newIdentity: ResourceIdentityData | undefined;
}
export interface PlanResourceChange {
}
export interface PlanResourceChange_Request {
    typeName: string;
    priorState: DynamicValue | undefined;
    proposedNewState: DynamicValue | undefined;
    config: DynamicValue | undefined;
    priorPrivate: Uint8Array;
    providerMeta: DynamicValue | undefined;
    clientCapabilities: ClientCapabilities | undefined;
    priorIdentity: ResourceIdentityData | undefined;
    plannedPrivate: Uint8Array;
}
export interface PlanResourceChange_Response {
    plannedState: DynamicValue | undefined;
    requiresReplace: AttributePath[];
    plannedPrivate: Uint8Array;
    diagnostics: Diagnostic[];
    /**
     * This may be set only by the helper/schema "SDK" in the main Terraform
     * repository, to request that Terraform Core >=0.12 permit additional
     * inconsistencies that can result from the legacy SDK type system
     * and its imprecise mapping to the >=0.12 type system.
     * The change in behavior implied by this flag makes sense only for the
     * specific details of the legacy SDK type system, and are not a general
     * mechanism to avoid proper type handling in providers.
     *
     *     ====              DO NOT USE THIS              ====
     *     ==== THIS MUST BE LEFT UNSET IN ALL OTHER SDKS ====
     *     ====              DO NOT USE THIS              ====
     */
    legacyTypeSystem: boolean;
    /**
     * deferred is set if the provider is deferring the change. If set the caller
     * needs to handle the deferral.
     */
    deferred: Deferred | undefined;
    plannedIdentity: ResourceIdentityData | undefined;
}
export interface ApplyResourceChange {
}
export interface ApplyResourceChange_Request {
    typeName: string;
    priorState: DynamicValue | undefined;
    plannedState: DynamicValue | undefined;
    config: DynamicValue | undefined;
    plannedPrivate: Uint8Array;
    providerMeta: DynamicValue | undefined;
    plannedIdentity: ResourceIdentityData | undefined;
}
export interface ApplyResourceChange_Response {
    newState: DynamicValue | undefined;
    private: Uint8Array;
    diagnostics: Diagnostic[];
    /**
     * This may be set only by the helper/schema "SDK" in the main Terraform
     * repository, to request that Terraform Core >=0.12 permit additional
     * inconsistencies that can result from the legacy SDK type system
     * and its imprecise mapping to the >=0.12 type system.
     * The change in behavior implied by this flag makes sense only for the
     * specific details of the legacy SDK type system, and are not a general
     * mechanism to avoid proper type handling in providers.
     *
     *     ====              DO NOT USE THIS              ====
     *     ==== THIS MUST BE LEFT UNSET IN ALL OTHER SDKS ====
     *     ====              DO NOT USE THIS              ====
     */
    legacyTypeSystem: boolean;
    newIdentity: ResourceIdentityData | undefined;
}
export interface ImportResourceState {
}
export interface ImportResourceState_Request {
    typeName: string;
    id: string;
    clientCapabilities: ClientCapabilities | undefined;
    identity: ResourceIdentityData | undefined;
}
export interface ImportResourceState_ImportedResource {
    typeName: string;
    state: DynamicValue | undefined;
    private: Uint8Array;
    identity: ResourceIdentityData | undefined;
}
export interface ImportResourceState_Response {
    importedResources: ImportResourceState_ImportedResource[];
    diagnostics: Diagnostic[];
    /**
     * deferred is set if the provider is deferring the change. If set the caller
     * needs to handle the deferral.
     */
    deferred: Deferred | undefined;
}
export interface GenerateResourceConfig {
}
export interface GenerateResourceConfig_Request {
    typeName: string;
    state: DynamicValue | undefined;
}
export interface GenerateResourceConfig_Response {
    /** config is the provided state modified such that it represents a valid resource configuration value. */
    config: DynamicValue | undefined;
    diagnostics: Diagnostic[];
}
export interface MoveResourceState {
}
export interface MoveResourceState_Request {
    /** The address of the provider the resource is being moved from. */
    sourceProviderAddress: string;
    /** The resource type that the resource is being moved from. */
    sourceTypeName: string;
    /**
     * The schema version of the resource type that the resource is being
     * moved from.
     */
    sourceSchemaVersion: Long;
    /**
     * The raw state of the resource being moved. Only the json field is
     * populated, as there should be no legacy providers using the flatmap
     * format that support newly introduced RPCs.
     */
    sourceState: RawState | undefined;
    /** The resource type that the resource is being moved to. */
    targetTypeName: string;
    /** The private state of the resource being moved. */
    sourcePrivate: Uint8Array;
    /**
     * The raw identity of the resource being moved. Only the json field is
     * populated, as there should be no legacy providers using the flatmap
     * format that support newly introduced RPCs.
     */
    sourceIdentity: RawState | undefined;
    /**
     * The identity schema version of the resource type that the resource
     * is being moved from.
     */
    sourceIdentitySchemaVersion: Long;
}
export interface MoveResourceState_Response {
    /** The state of the resource after it has been moved. */
    targetState: DynamicValue | undefined;
    /** Any diagnostics that occurred during the move. */
    diagnostics: Diagnostic[];
    /** The private state of the resource after it has been moved. */
    targetPrivate: Uint8Array;
    targetIdentity: ResourceIdentityData | undefined;
}
export interface ReadDataSource {
}
export interface ReadDataSource_Request {
    typeName: string;
    config: DynamicValue | undefined;
    providerMeta: DynamicValue | undefined;
    clientCapabilities: ClientCapabilities | undefined;
}
export interface ReadDataSource_Response {
    state: DynamicValue | undefined;
    diagnostics: Diagnostic[];
    /**
     * deferred is set if the provider is deferring the change. If set the caller
     * needs to handle the deferral.
     */
    deferred: Deferred | undefined;
}
export interface OpenEphemeralResource {
}
export interface OpenEphemeralResource_Request {
    typeName: string;
    config: DynamicValue | undefined;
    clientCapabilities: ClientCapabilities | undefined;
}
export interface OpenEphemeralResource_Response {
    diagnostics: Diagnostic[];
    renewAt?: Timestamp | undefined;
    result: DynamicValue | undefined;
    private?: Uint8Array | undefined;
    deferred: Deferred | undefined;
}
export interface RenewEphemeralResource {
}
export interface RenewEphemeralResource_Request {
    typeName: string;
    private?: Uint8Array | undefined;
}
export interface RenewEphemeralResource_Response {
    diagnostics: Diagnostic[];
    renewAt?: Timestamp | undefined;
    private?: Uint8Array | undefined;
}
export interface CloseEphemeralResource {
}
export interface CloseEphemeralResource_Request {
    typeName: string;
    private?: Uint8Array | undefined;
}
export interface CloseEphemeralResource_Response {
    diagnostics: Diagnostic[];
}
export interface GetFunctions {
}
export interface GetFunctions_Request {
}
export interface GetFunctions_Response {
    /** functions is a mapping of function names to definitions. */
    functions: {
        [key: string]: FunctionMessage;
    };
    /** diagnostics is any warnings or errors. */
    diagnostics: Diagnostic[];
}
export interface GetFunctions_Response_FunctionsEntry {
    key: string;
    value: FunctionMessage | undefined;
}
export interface CallFunction {
}
export interface CallFunction_Request {
    name: string;
    arguments: DynamicValue[];
}
export interface CallFunction_Response {
    result: DynamicValue | undefined;
    error: FunctionError | undefined;
}
export interface ListResource {
}
export interface ListResource_Request {
    /** type_name is the list resource type name. */
    typeName: string;
    /** configuration is the list ConfigSchema-based configuration data. */
    config: DynamicValue | undefined;
    /**
     * when include_resource_object is set to true, the provider should
     * include the full resource object for each result
     */
    includeResourceObject: boolean;
    /**
     * The maximum number of results that Terraform is expecting.
     * The stream will stop, once this limit is reached.
     */
    limit: Long;
}
export interface ListResource_Event {
    /** identity is the resource identity data of the resource instance. */
    identity: ResourceIdentityData | undefined;
    /** display_name can be displayed in a UI to make it easier for humans to identify a resource */
    displayName: string;
    /** optional resource object which can be useful when combining list blocks in configuration */
    resourceObject?: DynamicValue | undefined;
    /** A warning or error diagnostics for this event */
    diagnostic: Diagnostic[];
}
export interface ValidateListResourceConfig {
}
export interface ValidateListResourceConfig_Request {
    typeName: string;
    config: DynamicValue | undefined;
    includeResourceObject: DynamicValue | undefined;
    limit: DynamicValue | undefined;
}
export interface ValidateListResourceConfig_Response {
    diagnostics: Diagnostic[];
}
export interface ValidateStateStore {
}
export interface ValidateStateStore_Request {
    typeName: string;
    config: DynamicValue | undefined;
}
export interface ValidateStateStore_Response {
    diagnostics: Diagnostic[];
}
export interface ConfigureStateStore {
}
export interface ConfigureStateStore_Request {
    typeName: string;
    config: DynamicValue | undefined;
    capabilities: StateStoreClientCapabilities | undefined;
}
export interface ConfigureStateStore_Response {
    diagnostics: Diagnostic[];
    capabilities: StateStoreServerCapabilities | undefined;
}
export interface StateStoreClientCapabilities {
    /** suggested chunk size by Core */
    chunkSize: Long;
}
export interface StateStoreServerCapabilities {
    /** chosen chunk size by plugin */
    chunkSize: Long;
}
export interface ReadStateBytes {
}
export interface ReadStateBytes_Request {
    typeName: string;
    stateId: string;
}
export interface ReadStateBytes_Response {
    bytes: Uint8Array;
    /** total_length is the overall size of all of the state byte chunks that will be received */
    totalLength: Long;
    range: StateRange | undefined;
    diagnostics: Diagnostic[];
}
export interface WriteStateBytes {
}
export interface WriteStateBytes_RequestChunk {
    /** meta is sent with the first chunk only */
    meta?: RequestChunkMeta | undefined;
    bytes: Uint8Array;
    /** total_length is the overall size of all of the state byte chunks that will be sent. */
    totalLength: Long;
    range: StateRange | undefined;
}
export interface WriteStateBytes_Response {
    diagnostics: Diagnostic[];
}
export interface RequestChunkMeta {
    typeName: string;
    stateId: string;
}
export interface StateRange {
    /**
     * start is the starting byte index for a chunk of state byte data.
     * This index is in relation to the entire byte array that will be sent or received.
     */
    start: Long;
    /**
     * end is the ending byte index for a chunk of state byte data.
     * This index is in relation to the entire byte array that will be sent or received.
     */
    end: Long;
}
export interface LockState {
}
export interface LockState_Request {
    typeName: string;
    stateId: string;
    /** operation represents an ongoing operation due to which lock is held (e.g. refresh, plan, apply) */
    operation: string;
}
export interface LockState_Response {
    lockId: string;
    diagnostics: Diagnostic[];
}
export interface UnlockState {
}
export interface UnlockState_Request {
    typeName: string;
    stateId: string;
    lockId: string;
}
export interface UnlockState_Response {
    diagnostics: Diagnostic[];
}
export interface GetStates {
}
export interface GetStates_Request {
    typeName: string;
}
export interface GetStates_Response {
    stateId: string[];
    diagnostics: Diagnostic[];
}
export interface DeleteState {
}
export interface DeleteState_Request {
    typeName: string;
    stateId: string;
}
export interface DeleteState_Response {
    diagnostics: Diagnostic[];
}
export interface PlanAction {
}
export interface PlanAction_Request {
    actionType: string;
    /** config of the action, based on the schema of the actual action */
    config: DynamicValue | undefined;
    /** metadata */
    clientCapabilities: ClientCapabilities | undefined;
}
export interface PlanAction_Response {
    diagnostics: Diagnostic[];
    /** metadata */
    deferred: Deferred | undefined;
}
export interface InvokeAction {
}
export interface InvokeAction_Request {
    actionType: string;
    /** response from the plan */
    config: DynamicValue | undefined;
    /** metadata */
    clientCapabilities: ClientCapabilities | undefined;
}
export interface InvokeAction_Event {
    progress?: InvokeAction_Event_Progress | undefined;
    completed?: InvokeAction_Event_Completed | undefined;
}
export interface InvokeAction_Event_Progress {
    /** message to be printed in the console / HCPT */
    message: string;
}
export interface InvokeAction_Event_Completed {
    diagnostics: Diagnostic[];
}
export interface ValidateActionConfig {
}
export interface ValidateActionConfig_Request {
    typeName: string;
    config: DynamicValue | undefined;
}
export interface ValidateActionConfig_Response {
    diagnostics: Diagnostic[];
}
export declare const DynamicValue: MessageFns<DynamicValue>;
export declare const Diagnostic: MessageFns<Diagnostic>;
export declare const FunctionError: MessageFns<FunctionError>;
export declare const AttributePath: MessageFns<AttributePath>;
export declare const AttributePath_Step: MessageFns<AttributePath_Step>;
export declare const StopProvider: MessageFns<StopProvider>;
export declare const StopProvider_Request: MessageFns<StopProvider_Request>;
export declare const StopProvider_Response: MessageFns<StopProvider_Response>;
export declare const RawState: MessageFns<RawState>;
export declare const RawState_FlatmapEntry: MessageFns<RawState_FlatmapEntry>;
export declare const ResourceIdentitySchema: MessageFns<ResourceIdentitySchema>;
export declare const ResourceIdentitySchema_IdentityAttribute: MessageFns<ResourceIdentitySchema_IdentityAttribute>;
export declare const ResourceIdentityData: MessageFns<ResourceIdentityData>;
export declare const ActionSchema: MessageFns<ActionSchema>;
export declare const Schema: MessageFns<Schema>;
export declare const Schema_Block: MessageFns<Schema_Block>;
export declare const Schema_Attribute: MessageFns<Schema_Attribute>;
export declare const Schema_NestedBlock: MessageFns<Schema_NestedBlock>;
export declare const Schema_Object: MessageFns<Schema_Object>;
export declare const FunctionMessage: MessageFns<FunctionMessage>;
export declare const Function_Parameter: MessageFns<Function_Parameter>;
export declare const Function_Return: MessageFns<Function_Return>;
export declare const ServerCapabilities: MessageFns<ServerCapabilities>;
export declare const ClientCapabilities: MessageFns<ClientCapabilities>;
export declare const Deferred: MessageFns<Deferred>;
export declare const GetMetadata: MessageFns<GetMetadata>;
export declare const GetMetadata_Request: MessageFns<GetMetadata_Request>;
export declare const GetMetadata_Response: MessageFns<GetMetadata_Response>;
export declare const GetMetadata_EphemeralMetadata: MessageFns<GetMetadata_EphemeralMetadata>;
export declare const GetMetadata_FunctionMetadata: MessageFns<GetMetadata_FunctionMetadata>;
export declare const GetMetadata_DataSourceMetadata: MessageFns<GetMetadata_DataSourceMetadata>;
export declare const GetMetadata_ResourceMetadata: MessageFns<GetMetadata_ResourceMetadata>;
export declare const GetMetadata_ListResourceMetadata: MessageFns<GetMetadata_ListResourceMetadata>;
export declare const GetMetadata_StateStoreMetadata: MessageFns<GetMetadata_StateStoreMetadata>;
export declare const GetMetadata_ActionMetadata: MessageFns<GetMetadata_ActionMetadata>;
export declare const GetProviderSchema: MessageFns<GetProviderSchema>;
export declare const GetProviderSchema_Request: MessageFns<GetProviderSchema_Request>;
export declare const GetProviderSchema_Response: MessageFns<GetProviderSchema_Response>;
export declare const GetProviderSchema_Response_ResourceSchemasEntry: MessageFns<GetProviderSchema_Response_ResourceSchemasEntry>;
export declare const GetProviderSchema_Response_DataSourceSchemasEntry: MessageFns<GetProviderSchema_Response_DataSourceSchemasEntry>;
export declare const GetProviderSchema_Response_FunctionsEntry: MessageFns<GetProviderSchema_Response_FunctionsEntry>;
export declare const GetProviderSchema_Response_EphemeralResourceSchemasEntry: MessageFns<GetProviderSchema_Response_EphemeralResourceSchemasEntry>;
export declare const GetProviderSchema_Response_ListResourceSchemasEntry: MessageFns<GetProviderSchema_Response_ListResourceSchemasEntry>;
export declare const GetProviderSchema_Response_StateStoreSchemasEntry: MessageFns<GetProviderSchema_Response_StateStoreSchemasEntry>;
export declare const GetProviderSchema_Response_ActionSchemasEntry: MessageFns<GetProviderSchema_Response_ActionSchemasEntry>;
export declare const ValidateProviderConfig: MessageFns<ValidateProviderConfig>;
export declare const ValidateProviderConfig_Request: MessageFns<ValidateProviderConfig_Request>;
export declare const ValidateProviderConfig_Response: MessageFns<ValidateProviderConfig_Response>;
export declare const UpgradeResourceState: MessageFns<UpgradeResourceState>;
export declare const UpgradeResourceState_Request: MessageFns<UpgradeResourceState_Request>;
export declare const UpgradeResourceState_Response: MessageFns<UpgradeResourceState_Response>;
export declare const GetResourceIdentitySchemas: MessageFns<GetResourceIdentitySchemas>;
export declare const GetResourceIdentitySchemas_Request: MessageFns<GetResourceIdentitySchemas_Request>;
export declare const GetResourceIdentitySchemas_Response: MessageFns<GetResourceIdentitySchemas_Response>;
export declare const GetResourceIdentitySchemas_Response_IdentitySchemasEntry: MessageFns<GetResourceIdentitySchemas_Response_IdentitySchemasEntry>;
export declare const UpgradeResourceIdentity: MessageFns<UpgradeResourceIdentity>;
export declare const UpgradeResourceIdentity_Request: MessageFns<UpgradeResourceIdentity_Request>;
export declare const UpgradeResourceIdentity_Response: MessageFns<UpgradeResourceIdentity_Response>;
export declare const ValidateResourceConfig: MessageFns<ValidateResourceConfig>;
export declare const ValidateResourceConfig_Request: MessageFns<ValidateResourceConfig_Request>;
export declare const ValidateResourceConfig_Response: MessageFns<ValidateResourceConfig_Response>;
export declare const ValidateDataResourceConfig: MessageFns<ValidateDataResourceConfig>;
export declare const ValidateDataResourceConfig_Request: MessageFns<ValidateDataResourceConfig_Request>;
export declare const ValidateDataResourceConfig_Response: MessageFns<ValidateDataResourceConfig_Response>;
export declare const ValidateEphemeralResourceConfig: MessageFns<ValidateEphemeralResourceConfig>;
export declare const ValidateEphemeralResourceConfig_Request: MessageFns<ValidateEphemeralResourceConfig_Request>;
export declare const ValidateEphemeralResourceConfig_Response: MessageFns<ValidateEphemeralResourceConfig_Response>;
export declare const ConfigureProvider: MessageFns<ConfigureProvider>;
export declare const ConfigureProvider_Request: MessageFns<ConfigureProvider_Request>;
export declare const ConfigureProvider_Response: MessageFns<ConfigureProvider_Response>;
export declare const ReadResource: MessageFns<ReadResource>;
export declare const ReadResource_Request: MessageFns<ReadResource_Request>;
export declare const ReadResource_Response: MessageFns<ReadResource_Response>;
export declare const PlanResourceChange: MessageFns<PlanResourceChange>;
export declare const PlanResourceChange_Request: MessageFns<PlanResourceChange_Request>;
export declare const PlanResourceChange_Response: MessageFns<PlanResourceChange_Response>;
export declare const ApplyResourceChange: MessageFns<ApplyResourceChange>;
export declare const ApplyResourceChange_Request: MessageFns<ApplyResourceChange_Request>;
export declare const ApplyResourceChange_Response: MessageFns<ApplyResourceChange_Response>;
export declare const ImportResourceState: MessageFns<ImportResourceState>;
export declare const ImportResourceState_Request: MessageFns<ImportResourceState_Request>;
export declare const ImportResourceState_ImportedResource: MessageFns<ImportResourceState_ImportedResource>;
export declare const ImportResourceState_Response: MessageFns<ImportResourceState_Response>;
export declare const GenerateResourceConfig: MessageFns<GenerateResourceConfig>;
export declare const GenerateResourceConfig_Request: MessageFns<GenerateResourceConfig_Request>;
export declare const GenerateResourceConfig_Response: MessageFns<GenerateResourceConfig_Response>;
export declare const MoveResourceState: MessageFns<MoveResourceState>;
export declare const MoveResourceState_Request: MessageFns<MoveResourceState_Request>;
export declare const MoveResourceState_Response: MessageFns<MoveResourceState_Response>;
export declare const ReadDataSource: MessageFns<ReadDataSource>;
export declare const ReadDataSource_Request: MessageFns<ReadDataSource_Request>;
export declare const ReadDataSource_Response: MessageFns<ReadDataSource_Response>;
export declare const OpenEphemeralResource: MessageFns<OpenEphemeralResource>;
export declare const OpenEphemeralResource_Request: MessageFns<OpenEphemeralResource_Request>;
export declare const OpenEphemeralResource_Response: MessageFns<OpenEphemeralResource_Response>;
export declare const RenewEphemeralResource: MessageFns<RenewEphemeralResource>;
export declare const RenewEphemeralResource_Request: MessageFns<RenewEphemeralResource_Request>;
export declare const RenewEphemeralResource_Response: MessageFns<RenewEphemeralResource_Response>;
export declare const CloseEphemeralResource: MessageFns<CloseEphemeralResource>;
export declare const CloseEphemeralResource_Request: MessageFns<CloseEphemeralResource_Request>;
export declare const CloseEphemeralResource_Response: MessageFns<CloseEphemeralResource_Response>;
export declare const GetFunctions: MessageFns<GetFunctions>;
export declare const GetFunctions_Request: MessageFns<GetFunctions_Request>;
export declare const GetFunctions_Response: MessageFns<GetFunctions_Response>;
export declare const GetFunctions_Response_FunctionsEntry: MessageFns<GetFunctions_Response_FunctionsEntry>;
export declare const CallFunction: MessageFns<CallFunction>;
export declare const CallFunction_Request: MessageFns<CallFunction_Request>;
export declare const CallFunction_Response: MessageFns<CallFunction_Response>;
export declare const ListResource: MessageFns<ListResource>;
export declare const ListResource_Request: MessageFns<ListResource_Request>;
export declare const ListResource_Event: MessageFns<ListResource_Event>;
export declare const ValidateListResourceConfig: MessageFns<ValidateListResourceConfig>;
export declare const ValidateListResourceConfig_Request: MessageFns<ValidateListResourceConfig_Request>;
export declare const ValidateListResourceConfig_Response: MessageFns<ValidateListResourceConfig_Response>;
export declare const ValidateStateStore: MessageFns<ValidateStateStore>;
export declare const ValidateStateStore_Request: MessageFns<ValidateStateStore_Request>;
export declare const ValidateStateStore_Response: MessageFns<ValidateStateStore_Response>;
export declare const ConfigureStateStore: MessageFns<ConfigureStateStore>;
export declare const ConfigureStateStore_Request: MessageFns<ConfigureStateStore_Request>;
export declare const ConfigureStateStore_Response: MessageFns<ConfigureStateStore_Response>;
export declare const StateStoreClientCapabilities: MessageFns<StateStoreClientCapabilities>;
export declare const StateStoreServerCapabilities: MessageFns<StateStoreServerCapabilities>;
export declare const ReadStateBytes: MessageFns<ReadStateBytes>;
export declare const ReadStateBytes_Request: MessageFns<ReadStateBytes_Request>;
export declare const ReadStateBytes_Response: MessageFns<ReadStateBytes_Response>;
export declare const WriteStateBytes: MessageFns<WriteStateBytes>;
export declare const WriteStateBytes_RequestChunk: MessageFns<WriteStateBytes_RequestChunk>;
export declare const WriteStateBytes_Response: MessageFns<WriteStateBytes_Response>;
export declare const RequestChunkMeta: MessageFns<RequestChunkMeta>;
export declare const StateRange: MessageFns<StateRange>;
export declare const LockState: MessageFns<LockState>;
export declare const LockState_Request: MessageFns<LockState_Request>;
export declare const LockState_Response: MessageFns<LockState_Response>;
export declare const UnlockState: MessageFns<UnlockState>;
export declare const UnlockState_Request: MessageFns<UnlockState_Request>;
export declare const UnlockState_Response: MessageFns<UnlockState_Response>;
export declare const GetStates: MessageFns<GetStates>;
export declare const GetStates_Request: MessageFns<GetStates_Request>;
export declare const GetStates_Response: MessageFns<GetStates_Response>;
export declare const DeleteState: MessageFns<DeleteState>;
export declare const DeleteState_Request: MessageFns<DeleteState_Request>;
export declare const DeleteState_Response: MessageFns<DeleteState_Response>;
export declare const PlanAction: MessageFns<PlanAction>;
export declare const PlanAction_Request: MessageFns<PlanAction_Request>;
export declare const PlanAction_Response: MessageFns<PlanAction_Response>;
export declare const InvokeAction: MessageFns<InvokeAction>;
export declare const InvokeAction_Request: MessageFns<InvokeAction_Request>;
export declare const InvokeAction_Event: MessageFns<InvokeAction_Event>;
export declare const InvokeAction_Event_Progress: MessageFns<InvokeAction_Event_Progress>;
export declare const InvokeAction_Event_Completed: MessageFns<InvokeAction_Event_Completed>;
export declare const ValidateActionConfig: MessageFns<ValidateActionConfig>;
export declare const ValidateActionConfig_Request: MessageFns<ValidateActionConfig_Request>;
export declare const ValidateActionConfig_Response: MessageFns<ValidateActionConfig_Response>;
export interface ProviderServiceImplementation<CallContextExt = {}> {
    /**
     * GetMetadata returns upfront information about server capabilities and
     * supported resource types without requiring the server to instantiate all
     * schema information, which may be memory intensive.
     * This method is CURRENTLY UNUSED and it serves mostly for convenience
     * of code generation inside of terraform-plugin-mux.
     */
    getMetadata(request: GetMetadata_Request, context: CallContext & CallContextExt): Promise<DeepPartial<GetMetadata_Response>>;
    /**
     * GetSchema returns schema information for the provider, data resources,
     * and managed resources.
     */
    getProviderSchema(request: GetProviderSchema_Request, context: CallContext & CallContextExt): Promise<DeepPartial<GetProviderSchema_Response>>;
    validateProviderConfig(request: ValidateProviderConfig_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ValidateProviderConfig_Response>>;
    validateResourceConfig(request: ValidateResourceConfig_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ValidateResourceConfig_Response>>;
    validateDataResourceConfig(request: ValidateDataResourceConfig_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ValidateDataResourceConfig_Response>>;
    upgradeResourceState(request: UpgradeResourceState_Request, context: CallContext & CallContextExt): Promise<DeepPartial<UpgradeResourceState_Response>>;
    /**
     * GetResourceIdentitySchemas returns the identity schemas for all managed
     * resources.
     */
    getResourceIdentitySchemas(request: GetResourceIdentitySchemas_Request, context: CallContext & CallContextExt): Promise<DeepPartial<GetResourceIdentitySchemas_Response>>;
    /**
     * UpgradeResourceIdentityData should return the upgraded resource identity
     * data for a managed resource type.
     */
    upgradeResourceIdentity(request: UpgradeResourceIdentity_Request, context: CallContext & CallContextExt): Promise<DeepPartial<UpgradeResourceIdentity_Response>>;
    /** ////// One-time initialization, called before other functions below */
    configureProvider(request: ConfigureProvider_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ConfigureProvider_Response>>;
    /** ////// Managed Resource Lifecycle */
    readResource(request: ReadResource_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ReadResource_Response>>;
    planResourceChange(request: PlanResourceChange_Request, context: CallContext & CallContextExt): Promise<DeepPartial<PlanResourceChange_Response>>;
    applyResourceChange(request: ApplyResourceChange_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ApplyResourceChange_Response>>;
    importResourceState(request: ImportResourceState_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ImportResourceState_Response>>;
    moveResourceState(request: MoveResourceState_Request, context: CallContext & CallContextExt): Promise<DeepPartial<MoveResourceState_Response>>;
    readDataSource(request: ReadDataSource_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ReadDataSource_Response>>;
    generateResourceConfig(request: GenerateResourceConfig_Request, context: CallContext & CallContextExt): Promise<DeepPartial<GenerateResourceConfig_Response>>;
    /** ////// Ephemeral Resource Lifecycle */
    validateEphemeralResourceConfig(request: ValidateEphemeralResourceConfig_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ValidateEphemeralResourceConfig_Response>>;
    openEphemeralResource(request: OpenEphemeralResource_Request, context: CallContext & CallContextExt): Promise<DeepPartial<OpenEphemeralResource_Response>>;
    renewEphemeralResource(request: RenewEphemeralResource_Request, context: CallContext & CallContextExt): Promise<DeepPartial<RenewEphemeralResource_Response>>;
    closeEphemeralResource(request: CloseEphemeralResource_Request, context: CallContext & CallContextExt): Promise<DeepPartial<CloseEphemeralResource_Response>>;
    /** ///// List */
    listResource(request: ListResource_Request, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<ListResource_Event>>;
    validateListResourceConfig(request: ValidateListResourceConfig_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ValidateListResourceConfig_Response>>;
    /** GetFunctions returns the definitions of all functions. */
    getFunctions(request: GetFunctions_Request, context: CallContext & CallContextExt): Promise<DeepPartial<GetFunctions_Response>>;
    /** ////// Provider-contributed Functions */
    callFunction(request: CallFunction_Request, context: CallContext & CallContextExt): Promise<DeepPartial<CallFunction_Response>>;
    /** ValidateStateStoreConfig performs configuration validation */
    validateStateStoreConfig(request: ValidateStateStore_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ValidateStateStore_Response>>;
    /** ConfigureStateStore configures the state store, such as S3 connection in the context of already configured provider */
    configureStateStore(request: ConfigureStateStore_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ConfigureStateStore_Response>>;
    /** ReadStateBytes streams byte chunks of a given state file from a state store */
    readStateBytes(request: ReadStateBytes_Request, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<ReadStateBytes_Response>>;
    /** WriteStateBytes streams byte chunks of a given state file into a state store */
    writeStateBytes(request: AsyncIterable<WriteStateBytes_RequestChunk>, context: CallContext & CallContextExt): Promise<DeepPartial<WriteStateBytes_Response>>;
    /** LockState locks a given state (i.e. CE workspace) */
    lockState(request: LockState_Request, context: CallContext & CallContextExt): Promise<DeepPartial<LockState_Response>>;
    /** UnlockState unlocks a given state (i.e. CE workspace) */
    unlockState(request: UnlockState_Request, context: CallContext & CallContextExt): Promise<DeepPartial<UnlockState_Response>>;
    /** GetStates returns a list of all states (i.e. CE workspaces) managed by a given state store */
    getStates(request: GetStates_Request, context: CallContext & CallContextExt): Promise<DeepPartial<GetStates_Response>>;
    /** DeleteState instructs a given state store to delete a specific state (i.e. a CE workspace) */
    deleteState(request: DeleteState_Request, context: CallContext & CallContextExt): Promise<DeepPartial<DeleteState_Response>>;
    /** ////// Actions */
    planAction(request: PlanAction_Request, context: CallContext & CallContextExt): Promise<DeepPartial<PlanAction_Response>>;
    invokeAction(request: InvokeAction_Request, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<InvokeAction_Event>>;
    validateActionConfig(request: ValidateActionConfig_Request, context: CallContext & CallContextExt): Promise<DeepPartial<ValidateActionConfig_Response>>;
    /** ////// Graceful Shutdown */
    stopProvider(request: StopProvider_Request, context: CallContext & CallContextExt): Promise<DeepPartial<StopProvider_Response>>;
}
export interface ProviderClient<CallOptionsExt = {}> {
    /**
     * GetMetadata returns upfront information about server capabilities and
     * supported resource types without requiring the server to instantiate all
     * schema information, which may be memory intensive.
     * This method is CURRENTLY UNUSED and it serves mostly for convenience
     * of code generation inside of terraform-plugin-mux.
     */
    getMetadata(request: DeepPartial<GetMetadata_Request>, options?: CallOptions & CallOptionsExt): Promise<GetMetadata_Response>;
    /**
     * GetSchema returns schema information for the provider, data resources,
     * and managed resources.
     */
    getProviderSchema(request: DeepPartial<GetProviderSchema_Request>, options?: CallOptions & CallOptionsExt): Promise<GetProviderSchema_Response>;
    validateProviderConfig(request: DeepPartial<ValidateProviderConfig_Request>, options?: CallOptions & CallOptionsExt): Promise<ValidateProviderConfig_Response>;
    validateResourceConfig(request: DeepPartial<ValidateResourceConfig_Request>, options?: CallOptions & CallOptionsExt): Promise<ValidateResourceConfig_Response>;
    validateDataResourceConfig(request: DeepPartial<ValidateDataResourceConfig_Request>, options?: CallOptions & CallOptionsExt): Promise<ValidateDataResourceConfig_Response>;
    upgradeResourceState(request: DeepPartial<UpgradeResourceState_Request>, options?: CallOptions & CallOptionsExt): Promise<UpgradeResourceState_Response>;
    /**
     * GetResourceIdentitySchemas returns the identity schemas for all managed
     * resources.
     */
    getResourceIdentitySchemas(request: DeepPartial<GetResourceIdentitySchemas_Request>, options?: CallOptions & CallOptionsExt): Promise<GetResourceIdentitySchemas_Response>;
    /**
     * UpgradeResourceIdentityData should return the upgraded resource identity
     * data for a managed resource type.
     */
    upgradeResourceIdentity(request: DeepPartial<UpgradeResourceIdentity_Request>, options?: CallOptions & CallOptionsExt): Promise<UpgradeResourceIdentity_Response>;
    /** ////// One-time initialization, called before other functions below */
    configureProvider(request: DeepPartial<ConfigureProvider_Request>, options?: CallOptions & CallOptionsExt): Promise<ConfigureProvider_Response>;
    /** ////// Managed Resource Lifecycle */
    readResource(request: DeepPartial<ReadResource_Request>, options?: CallOptions & CallOptionsExt): Promise<ReadResource_Response>;
    planResourceChange(request: DeepPartial<PlanResourceChange_Request>, options?: CallOptions & CallOptionsExt): Promise<PlanResourceChange_Response>;
    applyResourceChange(request: DeepPartial<ApplyResourceChange_Request>, options?: CallOptions & CallOptionsExt): Promise<ApplyResourceChange_Response>;
    importResourceState(request: DeepPartial<ImportResourceState_Request>, options?: CallOptions & CallOptionsExt): Promise<ImportResourceState_Response>;
    moveResourceState(request: DeepPartial<MoveResourceState_Request>, options?: CallOptions & CallOptionsExt): Promise<MoveResourceState_Response>;
    readDataSource(request: DeepPartial<ReadDataSource_Request>, options?: CallOptions & CallOptionsExt): Promise<ReadDataSource_Response>;
    generateResourceConfig(request: DeepPartial<GenerateResourceConfig_Request>, options?: CallOptions & CallOptionsExt): Promise<GenerateResourceConfig_Response>;
    /** ////// Ephemeral Resource Lifecycle */
    validateEphemeralResourceConfig(request: DeepPartial<ValidateEphemeralResourceConfig_Request>, options?: CallOptions & CallOptionsExt): Promise<ValidateEphemeralResourceConfig_Response>;
    openEphemeralResource(request: DeepPartial<OpenEphemeralResource_Request>, options?: CallOptions & CallOptionsExt): Promise<OpenEphemeralResource_Response>;
    renewEphemeralResource(request: DeepPartial<RenewEphemeralResource_Request>, options?: CallOptions & CallOptionsExt): Promise<RenewEphemeralResource_Response>;
    closeEphemeralResource(request: DeepPartial<CloseEphemeralResource_Request>, options?: CallOptions & CallOptionsExt): Promise<CloseEphemeralResource_Response>;
    /** ///// List */
    listResource(request: DeepPartial<ListResource_Request>, options?: CallOptions & CallOptionsExt): AsyncIterable<ListResource_Event>;
    validateListResourceConfig(request: DeepPartial<ValidateListResourceConfig_Request>, options?: CallOptions & CallOptionsExt): Promise<ValidateListResourceConfig_Response>;
    /** GetFunctions returns the definitions of all functions. */
    getFunctions(request: DeepPartial<GetFunctions_Request>, options?: CallOptions & CallOptionsExt): Promise<GetFunctions_Response>;
    /** ////// Provider-contributed Functions */
    callFunction(request: DeepPartial<CallFunction_Request>, options?: CallOptions & CallOptionsExt): Promise<CallFunction_Response>;
    /** ValidateStateStoreConfig performs configuration validation */
    validateStateStoreConfig(request: DeepPartial<ValidateStateStore_Request>, options?: CallOptions & CallOptionsExt): Promise<ValidateStateStore_Response>;
    /** ConfigureStateStore configures the state store, such as S3 connection in the context of already configured provider */
    configureStateStore(request: DeepPartial<ConfigureStateStore_Request>, options?: CallOptions & CallOptionsExt): Promise<ConfigureStateStore_Response>;
    /** ReadStateBytes streams byte chunks of a given state file from a state store */
    readStateBytes(request: DeepPartial<ReadStateBytes_Request>, options?: CallOptions & CallOptionsExt): AsyncIterable<ReadStateBytes_Response>;
    /** WriteStateBytes streams byte chunks of a given state file into a state store */
    writeStateBytes(request: AsyncIterable<DeepPartial<WriteStateBytes_RequestChunk>>, options?: CallOptions & CallOptionsExt): Promise<WriteStateBytes_Response>;
    /** LockState locks a given state (i.e. CE workspace) */
    lockState(request: DeepPartial<LockState_Request>, options?: CallOptions & CallOptionsExt): Promise<LockState_Response>;
    /** UnlockState unlocks a given state (i.e. CE workspace) */
    unlockState(request: DeepPartial<UnlockState_Request>, options?: CallOptions & CallOptionsExt): Promise<UnlockState_Response>;
    /** GetStates returns a list of all states (i.e. CE workspaces) managed by a given state store */
    getStates(request: DeepPartial<GetStates_Request>, options?: CallOptions & CallOptionsExt): Promise<GetStates_Response>;
    /** DeleteState instructs a given state store to delete a specific state (i.e. a CE workspace) */
    deleteState(request: DeepPartial<DeleteState_Request>, options?: CallOptions & CallOptionsExt): Promise<DeleteState_Response>;
    /** ////// Actions */
    planAction(request: DeepPartial<PlanAction_Request>, options?: CallOptions & CallOptionsExt): Promise<PlanAction_Response>;
    invokeAction(request: DeepPartial<InvokeAction_Request>, options?: CallOptions & CallOptionsExt): AsyncIterable<InvokeAction_Event>;
    validateActionConfig(request: DeepPartial<ValidateActionConfig_Request>, options?: CallOptions & CallOptionsExt): Promise<ValidateActionConfig_Response>;
    /** ////// Graceful Shutdown */
    stopProvider(request: DeepPartial<StopProvider_Request>, options?: CallOptions & CallOptionsExt): Promise<StopProvider_Response>;
}
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
type KeysOfUnion<T> = T extends T ? keyof T : never;
export type Exact<P, I extends P> = P extends Builtin ? P : P & {
    [K in keyof P]: Exact<P[K], I[K]>;
} & {
    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
};
export type ServerStreamingMethodResult<Response> = {
    [Symbol.asyncIterator](): AsyncIterator<Response, void>;
};
export interface MessageFns<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}
export {};
//# sourceMappingURL=tfplugin6.d.ts.map