import * as x509 from '@peculiar/x509';
import * as _protobuf_ts_runtime from '@protobuf-ts/runtime';
import { MessageType, JsonWriteOptions, JsonValue, JsonReadOptions, PartialMessage, IBinaryReader, BinaryReadOptions, IBinaryWriter, BinaryWriteOptions } from '@protobuf-ts/runtime';
import * as _protobuf_ts_runtime_rpc from '@protobuf-ts/runtime-rpc';
import { ServiceType, RpcOptions, ServerStreamingCall, UnaryCall, ServiceInfo, RpcTransport } from '@protobuf-ts/runtime-rpc';

/**
 * `NullValue` is a singleton enumeration to represent the null value for the
 * `Value` type union.
 *
 *  The JSON representation for `NullValue` is JSON `null`.
 *
 * @generated from protobuf enum google.protobuf.NullValue
 */
declare enum NullValue {
    /**
     * Null value.
     *
     * @generated from protobuf enum value: NULL_VALUE = 0;
     */
    NULL_VALUE = 0
}
declare class Struct$Type extends MessageType<Struct> {
    constructor();
    /**
     * Encode `Struct` to JSON object.
     */
    internalJsonWrite(message: Struct, options: JsonWriteOptions): JsonValue;
    /**
     * Decode `Struct` from JSON object.
     */
    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Struct): Struct;
    create(value?: PartialMessage<Struct>): Struct;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Struct): Struct;
    private binaryReadMap1;
    internalBinaryWrite(message: Struct, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * `Struct` represents a structured data value, consisting of fields
 * which map to dynamically typed values. In some languages, `Struct`
 * might be supported by a native representation. For example, in
 * scripting languages like JS a struct is represented as an
 * object. The details of that representation are described together
 * with the proto support for the language.
 *
 * The JSON representation for `Struct` is JSON object.
 *
 * @generated from protobuf message google.protobuf.Struct
 */
interface Struct {
    /**
     * Unordered map of dynamically typed values.
     *
     * @generated from protobuf field: map<string, google.protobuf.Value> fields = 1;
     */
    fields: {
        [key: string]: Value;
    };
}
/**
 * @generated MessageType for protobuf message google.protobuf.Struct
 */
declare const Struct: Struct$Type;
declare class Value$Type extends MessageType<Value> {
    constructor();
    /**
     * Encode `Value` to JSON value.
     */
    internalJsonWrite(message: Value, options: JsonWriteOptions): JsonValue;
    /**
     * Decode `Value` from JSON value.
     */
    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Value): Value;
    create(value?: PartialMessage<Value>): Value;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Value): Value;
    internalBinaryWrite(message: Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * `Value` represents a dynamically typed value which can be either
 * null, a number, a string, a boolean, a recursive struct value, or a
 * list of values. A producer of value is expected to set one of these
 * variants. Absence of any variant indicates an error.
 *
 * The JSON representation for `Value` is JSON value.
 *
 * @generated from protobuf message google.protobuf.Value
 */
interface Value {
    /**
     * @generated from protobuf oneof: kind
     */
    kind: {
        oneofKind: 'nullValue';
        /**
         * Represents a null value.
         *
         * @generated from protobuf field: google.protobuf.NullValue null_value = 1;
         */
        nullValue: NullValue;
    } | {
        oneofKind: 'numberValue';
        /**
         * Represents a double value.
         *
         * @generated from protobuf field: double number_value = 2;
         */
        numberValue: number;
    } | {
        oneofKind: 'stringValue';
        /**
         * Represents a string value.
         *
         * @generated from protobuf field: string string_value = 3;
         */
        stringValue: string;
    } | {
        oneofKind: 'boolValue';
        /**
         * Represents a boolean value.
         *
         * @generated from protobuf field: bool bool_value = 4;
         */
        boolValue: boolean;
    } | {
        oneofKind: 'structValue';
        /**
         * Represents a structured value.
         *
         * @generated from protobuf field: google.protobuf.Struct struct_value = 5;
         */
        structValue: Struct;
    } | {
        oneofKind: 'listValue';
        /**
         * Represents a repeated `Value`.
         *
         * @generated from protobuf field: google.protobuf.ListValue list_value = 6;
         */
        listValue: ListValue;
    } | {
        oneofKind: undefined;
    };
}
/**
 * @generated MessageType for protobuf message google.protobuf.Value
 */
declare const Value: Value$Type;
declare class ListValue$Type extends MessageType<ListValue> {
    constructor();
    /**
     * Encode `ListValue` to JSON array.
     */
    internalJsonWrite(message: ListValue, options: JsonWriteOptions): JsonValue;
    /**
     * Decode `ListValue` from JSON array.
     */
    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: ListValue): ListValue;
    create(value?: PartialMessage<ListValue>): ListValue;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListValue): ListValue;
    internalBinaryWrite(message: ListValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * `ListValue` is a wrapper around a repeated field of values.
 *
 * The JSON representation for `ListValue` is JSON array.
 *
 * @generated from protobuf message google.protobuf.ListValue
 */
interface ListValue {
    /**
     * Repeated field of dynamically typed values.
     *
     * @generated from protobuf field: repeated google.protobuf.Value values = 1;
     */
    values: Value[];
}
/**
 * @generated MessageType for protobuf message google.protobuf.ListValue
 */
declare const ListValue: ListValue$Type;

declare class X509SVIDRequest$Type extends MessageType<X509SVIDRequest> {
    constructor();
    create(value?: PartialMessage<X509SVIDRequest>): X509SVIDRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: X509SVIDRequest): X509SVIDRequest;
    internalBinaryWrite(message: X509SVIDRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The X509SVIDRequest message conveys parameters for requesting an X.509-SVID.
 * There are currently no request parameters.
 *
 * @generated from protobuf message X509SVIDRequest
 */
interface X509SVIDRequest {
}
/**
 * @generated MessageType for protobuf message X509SVIDRequest
 */
declare const X509SVIDRequest: X509SVIDRequest$Type;
declare class X509SVIDResponse$Type extends MessageType<X509SVIDResponse> {
    constructor();
    create(value?: PartialMessage<X509SVIDResponse>): X509SVIDResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: X509SVIDResponse): X509SVIDResponse;
    private binaryReadMap3;
    internalBinaryWrite(message: X509SVIDResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The X509SVIDResponse message carries X.509-SVIDs and related information,
 * including a set of global CRLs and a list of bundles the workload may use
 * for federating with foreign trust domains.
 *
 * @generated from protobuf message X509SVIDResponse
 */
interface X509SVIDResponse {
    /**
     * Required. A list of X509SVID messages, each of which includes a single
     * X.509-SVID, its private key, and the bundle for the trust domain.
     *
     * @generated from protobuf field: repeated X509SVID svids = 1;
     */
    svids: X509SVID[];
    /**
     * Optional. ASN.1 DER encoded certificate revocation lists.
     *
     * @generated from protobuf field: repeated bytes crl = 2;
     */
    crl: Uint8Array[];
    /**
     * Optional. CA certificate bundles belonging to foreign trust domains that
     * the workload should trust, keyed by the SPIFFE ID of the foreign trust
     * domain. Bundles are ASN.1 DER encoded.
     *
     * @generated from protobuf field: map<string, bytes> federated_bundles = 3;
     */
    federatedBundles: {
        [key: string]: Uint8Array;
    };
}
/**
 * @generated MessageType for protobuf message X509SVIDResponse
 */
declare const X509SVIDResponse: X509SVIDResponse$Type;
declare class X509SVID$Type extends MessageType<X509SVID> {
    constructor();
    create(value?: PartialMessage<X509SVID>): X509SVID;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: X509SVID): X509SVID;
    internalBinaryWrite(message: X509SVID, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The X509SVID message carries a single SVID and all associated information,
 * including the X.509 bundle for the trust domain.
 *
 * @generated from protobuf message X509SVID
 */
interface X509SVID {
    /**
     * Required. The SPIFFE ID of the SVID in this entry
     *
     * @generated from protobuf field: string spiffe_id = 1;
     */
    spiffeId: string;
    /**
     * Required. ASN.1 DER encoded certificate chain. MAY include
     * intermediates, the leaf certificate (or SVID itself) MUST come first.
     *
     * @generated from protobuf field: bytes x509_svid = 2;
     */
    x509Svid: Uint8Array;
    /**
     * Required. ASN.1 DER encoded PKCS#8 private key. MUST be unencrypted.
     *
     * @generated from protobuf field: bytes x509_svid_key = 3;
     */
    x509SvidKey: Uint8Array;
    /**
     * Required. ASN.1 DER encoded X.509 bundle for the trust domain.
     *
     * @generated from protobuf field: bytes bundle = 4;
     */
    bundle: Uint8Array;
    /**
     * Optional. An operator-specified string used to provide guidance on how this
     * identity should be used by a workload when more than one SVID is returned.
     * For example, `internal` and `external` to indicate an SVID for internal or
     * external use, respectively.
     *
     * @generated from protobuf field: string hint = 5;
     */
    hint: string;
}
/**
 * @generated MessageType for protobuf message X509SVID
 */
declare const X509SVID: X509SVID$Type;
declare class X509BundlesRequest$Type extends MessageType<X509BundlesRequest> {
    constructor();
    create(value?: PartialMessage<X509BundlesRequest>): X509BundlesRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: X509BundlesRequest): X509BundlesRequest;
    internalBinaryWrite(message: X509BundlesRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The X509BundlesRequest message conveys parameters for requesting X.509
 * bundles. There are currently no such parameters.
 *
 * @generated from protobuf message X509BundlesRequest
 */
interface X509BundlesRequest {
}
/**
 * @generated MessageType for protobuf message X509BundlesRequest
 */
declare const X509BundlesRequest: X509BundlesRequest$Type;
declare class X509BundlesResponse$Type extends MessageType<X509BundlesResponse> {
    constructor();
    create(value?: PartialMessage<X509BundlesResponse>): X509BundlesResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: X509BundlesResponse): X509BundlesResponse;
    private binaryReadMap2;
    internalBinaryWrite(message: X509BundlesResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The X509BundlesResponse message carries a set of global CRLs and a map of
 * trust bundles the workload should trust.
 *
 * @generated from protobuf message X509BundlesResponse
 */
interface X509BundlesResponse {
    /**
     * Optional. ASN.1 DER encoded certificate revocation lists.
     *
     * @generated from protobuf field: repeated bytes crl = 1;
     */
    crl: Uint8Array[];
    /**
     * Required. CA certificate bundles belonging to trust domains that the
     * workload should trust, keyed by the SPIFFE ID of the trust domain.
     * Bundles are ASN.1 DER encoded.
     *
     * @generated from protobuf field: map<string, bytes> bundles = 2;
     */
    bundles: {
        [key: string]: Uint8Array;
    };
}
/**
 * @generated MessageType for protobuf message X509BundlesResponse
 */
declare const X509BundlesResponse: X509BundlesResponse$Type;
declare class JWTSVIDRequest$Type extends MessageType<JWTSVIDRequest> {
    constructor();
    create(value?: PartialMessage<JWTSVIDRequest>): JWTSVIDRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: JWTSVIDRequest): JWTSVIDRequest;
    internalBinaryWrite(message: JWTSVIDRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated from protobuf message JWTSVIDRequest
 */
interface JWTSVIDRequest {
    /**
     * Required. The audience(s) the workload intends to authenticate against.
     *
     * @generated from protobuf field: repeated string audience = 1;
     */
    audience: string[];
    /**
     * Optional. The requested SPIFFE ID for the JWT-SVID. If unset, all
     * JWT-SVIDs to which the workload is entitled are requested.
     *
     * @generated from protobuf field: string spiffe_id = 2;
     */
    spiffeId: string;
}
/**
 * @generated MessageType for protobuf message JWTSVIDRequest
 */
declare const JWTSVIDRequest: JWTSVIDRequest$Type;
declare class JWTSVIDResponse$Type extends MessageType<JWTSVIDResponse> {
    constructor();
    create(value?: PartialMessage<JWTSVIDResponse>): JWTSVIDResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: JWTSVIDResponse): JWTSVIDResponse;
    internalBinaryWrite(message: JWTSVIDResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The JWTSVIDResponse message conveys JWT-SVIDs.
 *
 * @generated from protobuf message JWTSVIDResponse
 */
interface JWTSVIDResponse {
    /**
     * Required. The list of returned JWT-SVIDs.
     *
     * @generated from protobuf field: repeated JWTSVID svids = 1;
     */
    svids: JWTSVID[];
}
/**
 * @generated MessageType for protobuf message JWTSVIDResponse
 */
declare const JWTSVIDResponse: JWTSVIDResponse$Type;
declare class JWTSVID$Type extends MessageType<JWTSVID> {
    constructor();
    create(value?: PartialMessage<JWTSVID>): JWTSVID;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: JWTSVID): JWTSVID;
    internalBinaryWrite(message: JWTSVID, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The JWTSVID message carries the JWT-SVID token and associated metadata.
 *
 * @generated from protobuf message JWTSVID
 */
interface JWTSVID {
    /**
     * Required. The SPIFFE ID of the JWT-SVID.
     *
     * @generated from protobuf field: string spiffe_id = 1;
     */
    spiffeId: string;
    /**
     * Required. Encoded JWT using JWS Compact Serialization.
     *
     * @generated from protobuf field: string svid = 2;
     */
    svid: string;
    /**
     * Optional. An operator-specified string used to provide guidance on how this
     * identity should be used by a workload when more than one SVID is returned.
     * For example, `internal` and `external` to indicate an SVID for internal or
     * external use, respectively.
     *
     * @generated from protobuf field: string hint = 3;
     */
    hint: string;
}
/**
 * @generated MessageType for protobuf message JWTSVID
 */
declare const JWTSVID: JWTSVID$Type;
declare class JWTBundlesRequest$Type extends MessageType<JWTBundlesRequest> {
    constructor();
    create(value?: PartialMessage<JWTBundlesRequest>): JWTBundlesRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: JWTBundlesRequest): JWTBundlesRequest;
    internalBinaryWrite(message: JWTBundlesRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The JWTBundlesRequest message conveys parameters for requesting JWT bundles.
 * There are currently no such parameters.
 *
 * @generated from protobuf message JWTBundlesRequest
 */
interface JWTBundlesRequest {
}
/**
 * @generated MessageType for protobuf message JWTBundlesRequest
 */
declare const JWTBundlesRequest: JWTBundlesRequest$Type;
declare class JWTBundlesResponse$Type extends MessageType<JWTBundlesResponse> {
    constructor();
    create(value?: PartialMessage<JWTBundlesResponse>): JWTBundlesResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: JWTBundlesResponse): JWTBundlesResponse;
    private binaryReadMap1;
    internalBinaryWrite(message: JWTBundlesResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The JWTBundlesReponse conveys JWT bundles.
 *
 * @generated from protobuf message JWTBundlesResponse
 */
interface JWTBundlesResponse {
    /**
     * Required. JWK encoded JWT bundles, keyed by the SPIFFE ID of the trust
     * domain.
     *
     * @generated from protobuf field: map<string, bytes> bundles = 1;
     */
    bundles: {
        [key: string]: Uint8Array;
    };
}
/**
 * @generated MessageType for protobuf message JWTBundlesResponse
 */
declare const JWTBundlesResponse: JWTBundlesResponse$Type;
declare class ValidateJWTSVIDRequest$Type extends MessageType<ValidateJWTSVIDRequest> {
    constructor();
    create(value?: PartialMessage<ValidateJWTSVIDRequest>): ValidateJWTSVIDRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ValidateJWTSVIDRequest): ValidateJWTSVIDRequest;
    internalBinaryWrite(message: ValidateJWTSVIDRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The ValidateJWTSVIDRequest message conveys request parameters for
 * JWT-SVID validation.
 *
 * @generated from protobuf message ValidateJWTSVIDRequest
 */
interface ValidateJWTSVIDRequest {
    /**
     * Required. The audience of the validating party. The JWT-SVID must
     * contain an audience claim which contains this value in order to
     * succesfully validate.
     *
     * @generated from protobuf field: string audience = 1;
     */
    audience: string;
    /**
     * Required. The JWT-SVID to validate, encoded using JWS Compact
     * Serialization.
     *
     * @generated from protobuf field: string svid = 2;
     */
    svid: string;
}
/**
 * @generated MessageType for protobuf message ValidateJWTSVIDRequest
 */
declare const ValidateJWTSVIDRequest: ValidateJWTSVIDRequest$Type;
declare class ValidateJWTSVIDResponse$Type extends MessageType<ValidateJWTSVIDResponse> {
    constructor();
    create(value?: PartialMessage<ValidateJWTSVIDResponse>): ValidateJWTSVIDResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ValidateJWTSVIDResponse): ValidateJWTSVIDResponse;
    internalBinaryWrite(message: ValidateJWTSVIDResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * The ValidateJWTSVIDReponse message conveys the JWT-SVID validation results.
 *
 * @generated from protobuf message ValidateJWTSVIDResponse
 */
interface ValidateJWTSVIDResponse {
    /**
     * Required. The SPIFFE ID of the validated JWT-SVID.
     *
     * @generated from protobuf field: string spiffe_id = 1;
     */
    spiffeId: string;
    /**
     * Required. Claims contained within the payload of the validated JWT-SVID.
     * This includes both SPIFFE-required and non-required claims.
     *
     * @generated from protobuf field: google.protobuf.Struct claims = 2;
     */
    claims?: Struct;
}
/**
 * @generated MessageType for protobuf message ValidateJWTSVIDResponse
 */
declare const ValidateJWTSVIDResponse: ValidateJWTSVIDResponse$Type;
/**
 * @generated ServiceType for protobuf service SpiffeWorkloadAPI
 */
declare const SpiffeWorkloadAPI: ServiceType;

/**
 * ///////////////////////////////////////////////////////////////////////
 * X509-SVID Profile
 * ///////////////////////////////////////////////////////////////////////
 *
 * @generated from protobuf service SpiffeWorkloadAPI
 */
interface ISpiffeWorkloadAPIClient {
    /**
     * Fetch X.509-SVIDs for all SPIFFE identities the workload is entitled to,
     * as well as related information like trust bundles and CRLs. As this
     * information changes, subsequent messages will be streamed from the
     * server.
     *
     * @generated from protobuf rpc: FetchX509SVID(X509SVIDRequest) returns (stream X509SVIDResponse);
     */
    fetchX509SVID(input: X509SVIDRequest, options?: RpcOptions): ServerStreamingCall<X509SVIDRequest, X509SVIDResponse>;
    /**
     * Fetch trust bundles and CRLs. Useful for clients that only need to
     * validate SVIDs without obtaining an SVID for themself. As this
     * information changes, subsequent messages will be streamed from the
     * server.
     *
     * @generated from protobuf rpc: FetchX509Bundles(X509BundlesRequest) returns (stream X509BundlesResponse);
     */
    fetchX509Bundles(input: X509BundlesRequest, options?: RpcOptions): ServerStreamingCall<X509BundlesRequest, X509BundlesResponse>;
    /**
     * Fetch JWT-SVIDs for all SPIFFE identities the workload is entitled to,
     * for the requested audience. If an optional SPIFFE ID is requested, only
     * the JWT-SVID for that SPIFFE ID is returned.
     *
     * @generated from protobuf rpc: FetchJWTSVID(JWTSVIDRequest) returns (JWTSVIDResponse);
     */
    fetchJWTSVID(input: JWTSVIDRequest, options?: RpcOptions): UnaryCall<JWTSVIDRequest, JWTSVIDResponse>;
    /**
     * Fetches the JWT bundles, formatted as JWKS documents, keyed by the
     * SPIFFE ID of the trust domain. As this information changes, subsequent
     * messages will be streamed from the server.
     *
     * @generated from protobuf rpc: FetchJWTBundles(JWTBundlesRequest) returns (stream JWTBundlesResponse);
     */
    fetchJWTBundles(input: JWTBundlesRequest, options?: RpcOptions): ServerStreamingCall<JWTBundlesRequest, JWTBundlesResponse>;
    /**
     * Validates a JWT-SVID against the requested audience. Returns the SPIFFE
     * ID of the JWT-SVID and JWT claims.
     *
     * @generated from protobuf rpc: ValidateJWTSVID(ValidateJWTSVIDRequest) returns (ValidateJWTSVIDResponse);
     */
    validateJWTSVID(input: ValidateJWTSVIDRequest, options?: RpcOptions): UnaryCall<ValidateJWTSVIDRequest, ValidateJWTSVIDResponse>;
}
/**
 * ///////////////////////////////////////////////////////////////////////
 * X509-SVID Profile
 * ///////////////////////////////////////////////////////////////////////
 *
 * @generated from protobuf service SpiffeWorkloadAPI
 */
declare class SpiffeWorkloadAPIClient implements ISpiffeWorkloadAPIClient, ServiceInfo {
    private readonly _transport;
    typeName: string;
    methods: _protobuf_ts_runtime_rpc.MethodInfo<any, any>[];
    options: {
        [extensionName: string]: _protobuf_ts_runtime.JsonValue;
    };
    constructor(_transport: RpcTransport);
    /**
     * Fetch X.509-SVIDs for all SPIFFE identities the workload is entitled to,
     * as well as related information like trust bundles and CRLs. As this
     * information changes, subsequent messages will be streamed from the
     * server.
     *
     * @generated from protobuf rpc: FetchX509SVID(X509SVIDRequest) returns (stream X509SVIDResponse);
     */
    fetchX509SVID(input: X509SVIDRequest, options?: RpcOptions): ServerStreamingCall<X509SVIDRequest, X509SVIDResponse>;
    /**
     * Fetch trust bundles and CRLs. Useful for clients that only need to
     * validate SVIDs without obtaining an SVID for themself. As this
     * information changes, subsequent messages will be streamed from the
     * server.
     *
     * @generated from protobuf rpc: FetchX509Bundles(X509BundlesRequest) returns (stream X509BundlesResponse);
     */
    fetchX509Bundles(input: X509BundlesRequest, options?: RpcOptions): ServerStreamingCall<X509BundlesRequest, X509BundlesResponse>;
    /**
     * Fetch JWT-SVIDs for all SPIFFE identities the workload is entitled to,
     * for the requested audience. If an optional SPIFFE ID is requested, only
     * the JWT-SVID for that SPIFFE ID is returned.
     *
     * @generated from protobuf rpc: FetchJWTSVID(JWTSVIDRequest) returns (JWTSVIDResponse);
     */
    fetchJWTSVID(input: JWTSVIDRequest, options?: RpcOptions): UnaryCall<JWTSVIDRequest, JWTSVIDResponse>;
    /**
     * Fetches the JWT bundles, formatted as JWKS documents, keyed by the
     * SPIFFE ID of the trust domain. As this information changes, subsequent
     * messages will be streamed from the server.
     *
     * @generated from protobuf rpc: FetchJWTBundles(JWTBundlesRequest) returns (stream JWTBundlesResponse);
     */
    fetchJWTBundles(input: JWTBundlesRequest, options?: RpcOptions): ServerStreamingCall<JWTBundlesRequest, JWTBundlesResponse>;
    /**
     * Validates a JWT-SVID against the requested audience. Returns the SPIFFE
     * ID of the JWT-SVID and JWT claims.
     *
     * @generated from protobuf rpc: ValidateJWTSVID(ValidateJWTSVIDRequest) returns (ValidateJWTSVIDResponse);
     */
    validateJWTSVID(input: ValidateJWTSVIDRequest, options?: RpcOptions): UnaryCall<ValidateJWTSVIDRequest, ValidateJWTSVIDResponse>;
}

declare function createClient(baseURL?: string): SpiffeWorkloadAPIClient;
/**
 * Utility function to parse a raw certificate. Can be used to convert the
 * raw certificate into a PEM certificate:
 *
 * ```typescript
 * const cert = parseCertificate(data)
 * const pem = cert.toString('pem')
 * ```
 *
 * **Note:** if you have a certificate bundle, use `parseCertificateBundle` instead, as
 * this function will incorrectly parse bundles as a single certificate.
 *
 * @param data The raw data of the certificate
 * @returns [X509Certificate](https://peculiarventures.github.io/x509/classes/X509Certificate.html)
 * @see https://github.com/PeculiarVentures/x509
 */
declare function parseCertificate(data: Uint8Array): x509.X509Certificate;
/**
 * Utility function to parse a certificate bundle. Can be used to convert the
 * bundle into a PEM chain:
 *
 * ```typescript
 * const certs = parseCertificateBundle(data)
 * const pemChain = certs.toString('pem-chain')
 * ```
 *
 * @param data The raw data of the certificate bundle
 * @returns [X509Certificates](https://peculiarventures.github.io/x509/classes/X509Certificates.html)
 * @see https://github.com/PeculiarVentures/x509
 */
declare function parseCertificateBundle(data: Uint8Array): x509.X509Certificates;

export { type ISpiffeWorkloadAPIClient, JWTBundlesRequest, JWTBundlesResponse, JWTSVID, JWTSVIDRequest, JWTSVIDResponse, ListValue, NullValue, SpiffeWorkloadAPI, SpiffeWorkloadAPIClient, Struct, ValidateJWTSVIDRequest, ValidateJWTSVIDResponse, Value, X509BundlesRequest, X509BundlesResponse, X509SVID, X509SVIDRequest, X509SVIDResponse, createClient, parseCertificate, parseCertificateBundle };