import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
export declare const protobufPackage = "snapchat.lenses";
/** Data interface used by an API endpoint */
export declare enum RemoteApiEndpointType {
    /** TYPE_UNSET - Invalid empty value */
    TYPE_UNSET = "TYPE_UNSET",
    /** TEXT - Text-based API, usually JSON */
    TEXT = "TEXT",
    /** PROTO - Protobuf-based API, request and response are proto messages */
    PROTO = "PROTO",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function remoteApiEndpointTypeFromJSON(object: any): RemoteApiEndpointType;
export declare function remoteApiEndpointTypeToNumber(object: RemoteApiEndpointType): number;
/** Defines caching behavior for an endpoint */
export declare enum RemoteApiCacheStrategy {
    /** CS_UNSET - Invalid empty value */
    CS_UNSET = "CS_UNSET",
    /** USE_HEADERS - Rely on Cache-control headers */
    USE_HEADERS = "USE_HEADERS",
    /** ALWAYS - Always cache */
    ALWAYS = "ALWAYS",
    /** NEVER - Never cache */
    NEVER = "NEVER",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function remoteApiCacheStrategyFromJSON(object: any): RemoteApiCacheStrategy;
export declare function remoteApiCacheStrategyToNumber(object: RemoteApiCacheStrategy): number;
/**
 * Normally, proxy relies on the response Cache-control header to determine cache TTL.
 * When to override 3p API-provided cache TTL with the one specified in the spec
 */
export declare enum RemoteApiCacheTTLStrategy {
    /** CTS_UNSET - Never override TTL from Cache-control header */
    CTS_UNSET = "CTS_UNSET",
    /** EXACT - Always use spec-provided TTL, ignore Cache-control header */
    EXACT = "EXACT",
    /** FLOOR - Use spec-provided TTL if Cache-control TTL is less */
    FLOOR = "FLOOR",
    /** CEILING - Use spec-provided TTL if Cache-control TTL is greater */
    CEILING = "CEILING",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function remoteApiCacheTTLStrategyFromJSON(object: any): RemoteApiCacheTTLStrategy;
export declare function remoteApiCacheTTLStrategyToNumber(object: RemoteApiCacheTTLStrategy): number;
/** Options in HTTP request to run through ALD (Abuse Language Detection) */
export declare enum AldRequestValidationConfig {
    /** ALD_REQ_CONFIG_UNSET - Unset */
    ALD_REQ_CONFIG_UNSET = "ALD_REQ_CONFIG_UNSET",
    /** REQ_BODY - Request Body */
    REQ_BODY = "REQ_BODY",
    /** REQ_URL - Request URL */
    REQ_URL = "REQ_URL",
    /** REQ_HEADERS - Request headers */
    REQ_HEADERS = "REQ_HEADERS",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function aldRequestValidationConfigFromJSON(object: any): AldRequestValidationConfig;
export declare function aldRequestValidationConfigToNumber(object: AldRequestValidationConfig): number;
/** Options in HTTP response to run through ALD (Abuse Language Detection) */
export declare enum AldResponseValidationConfig {
    /** ALD_RESP_CONFIG_UNSET - Unset */
    ALD_RESP_CONFIG_UNSET = "ALD_RESP_CONFIG_UNSET",
    /** RESP_BODY - Response Body */
    RESP_BODY = "RESP_BODY",
    /** RESP_HEADERS - Response headers */
    RESP_HEADERS = "RESP_HEADERS",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function aldResponseValidationConfigFromJSON(object: any): AldResponseValidationConfig;
export declare function aldResponseValidationConfigToNumber(object: AldResponseValidationConfig): number;
/**
 * Approval state of an API spec
 * See more: https://docs.google.com/document/d/1uNuHwRT6a5_XBNQ1gZGNpdNVUEaTTCYkMFtnj7r3Z24/edit?usp=sharing
 */
export declare enum SpecApprovalState {
    /** APPROVAL_STATE_UNSET - Invalid value */
    APPROVAL_STATE_UNSET = "APPROVAL_STATE_UNSET",
    /** IN_REVIEW - In review */
    IN_REVIEW = "IN_REVIEW",
    /** APPROVED - Approved */
    APPROVED = "APPROVED",
    /** BLOCKED - Blocked */
    BLOCKED = "BLOCKED",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function specApprovalStateFromJSON(object: any): SpecApprovalState;
export declare function specApprovalStateToNumber(object: SpecApprovalState): number;
/** Who should be able to see/use the spec */
export declare enum SpecVisibility {
    /** VISIBILITY_UNSET - Invalid value */
    VISIBILITY_UNSET = "VISIBILITY_UNSET",
    /**
     * INTERNAL - Only internal Lens Studio versions
     *
     * @deprecated
     */
    INTERNAL = "INTERNAL",
    /** PRIVATE - Only the spec creator and those on allowlist */
    PRIVATE = "PRIVATE",
    /** EXTERNAL - Accessible to everyone */
    EXTERNAL = "EXTERNAL",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function specVisibilityFromJSON(object: any): SpecVisibility;
export declare function specVisibilityToNumber(object: SpecVisibility): number;
/**
 * Where was this api created from; in the future we may end up with
 * different behavior for Specs created from different properties
 */
export declare enum CreatedFrom {
    /** CREATED_FROM_UNSET - Invalid value */
    CREATED_FROM_UNSET = "CREATED_FROM_UNSET",
    /** REMOTE_API_ADMIN - This was created on Remote-Api-Admin by an internal team member */
    REMOTE_API_ADMIN = "REMOTE_API_ADMIN",
    /** MY_LENSES - This was created on My-Lenses by an external team member */
    MY_LENSES = "MY_LENSES",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function createdFromFromJSON(object: any): CreatedFrom;
export declare function createdFromToNumber(object: CreatedFrom): number;
/** What platform this spec is targeting */
export declare enum TargetPlatform {
    /** TARGET_PLATFORM_UNSET - Invalid value */
    TARGET_PLATFORM_UNSET = "TARGET_PLATFORM_UNSET",
    /** SNAPCHAT - Accessible to lenses on Snapchat */
    SNAPCHAT = "SNAPCHAT",
    /** SPECTACLES - Accessible to lenses on Spectacles */
    SPECTACLES = "SPECTACLES",
    /** CAMERA_KIT - Accessible to CameraKit */
    CAMERA_KIT = "CAMERA_KIT",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function targetPlatformFromJSON(object: any): TargetPlatform;
export declare function targetPlatformToNumber(object: TargetPlatform): number;
/** Defines which api access level the lens has: https://snapchat.quip.com/RS86Adtd8lZI */
export declare enum RestrictedJsApiPermission {
    /** PERMISSION_UNSET - Invalid value */
    PERMISSION_UNSET = "PERMISSION_UNSET",
    /** USER_DATA - Lenses that use this API can access user data */
    USER_DATA = "USER_DATA",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function restrictedJsApiPermissionFromJSON(object: any): RestrictedJsApiPermission;
export declare function restrictedJsApiPermissionToNumber(object: RestrictedJsApiPermission): number;
/** (only for internal API endpoints) Possible use cases for user location */
export declare enum UserLocationUseCase {
    /** USE_CASE_UNSET - Undefined use case */
    USE_CASE_UNSET = "USE_CASE_UNSET",
    /** WEATHER - Weather info in user area (zoom level 10) */
    WEATHER = "WEATHER",
    /** PLACES - Finding nearby places (zoom level 18) */
    PLACES = "PLACES",
    /** PLACES_COARSE - Finding nearby places at a more coarse level (zoom level 17) */
    PLACES_COARSE = "PLACES_COARSE",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function userLocationUseCaseFromJSON(object: any): UserLocationUseCase;
export declare function userLocationUseCaseToNumber(object: UserLocationUseCase): number;
/** Defines how a parameter is injected into an HTTP request */
export interface RemoteApiHttpRequestParameter {
    /** Unique name of the parameter */
    name: string;
    /** Location of the parameter */
    location: RemoteApiHttpRequestParameter_ParameterLocation;
    /** Is parameter optional */
    optional: boolean;
    /**
     * (optional) Name of the parameter that will be used to construct the request (in query/headers/path).
     * `name` is used by clients to fill in the parameters in the request, whereas
     * `external_name` is what is used in the outgoing API request by the proxy.
     * If empty, `external_name` is assumed to be the same as `name`.
     */
    externalName: string;
    /**
     * Default value if the parameter is not set. Useful for "standard" headers like content-type
     * and other similar cases. If a default value is provided, the parameter will be sent with every request.
     * Required for constant parameters.
     */
    defaultValue: string;
    /**
     * Constant parameters have the same predefined value for all requests and
     * are always set by the proxy. Not allowed to be overridden by the caller.
     */
    constant: boolean;
}
/** Possible location of a parameter */
export declare enum RemoteApiHttpRequestParameter_ParameterLocation {
    /** LOCATION_UNSET - Undefined location */
    LOCATION_UNSET = "LOCATION_UNSET",
    /** QUERY - Parameters that appear in the URL query */
    QUERY = "QUERY",
    /** HEADER - Parameters that appear in the HTTP request header */
    HEADER = "HEADER",
    /** PATH - Parameters that appear in the URL path (for parameterized path only) */
    PATH = "PATH",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function remoteApiHttpRequestParameter_ParameterLocationFromJSON(object: any): RemoteApiHttpRequestParameter_ParameterLocation;
export declare function remoteApiHttpRequestParameter_ParameterLocationToNumber(object: RemoteApiHttpRequestParameter_ParameterLocation): number;
/** (only for PROTO endpoints) Represents names of fields in a proto response, as well as an optional macro value */
export interface RemoteApiHttpResponseParameter {
    /** Unique name of the parameter */
    name: string;
    /** Whether or not we want to expose this parameter in the final API response to user */
    hidden: boolean;
    /** Specific macro values indicate certain parameters and types that we want to map this proto field to. */
    macroValue: string;
}
/** Metadata for remote API endpoints */
export interface RemoteApiEndpointMetadata {
    /** Human-readable name for the endpoint */
    name: string;
    /** Description that may include links to documentation, etc. */
    description: string;
}
/** Determines how the proxy should cache third party responses */
export interface RemoteApiCachingConfig {
    /** When to cache */
    cacheStrategy: RemoteApiCacheStrategy;
    /** Which TTL to use when caching */
    ttlStrategy: RemoteApiCacheTTLStrategy;
    /** Custom TTL override value */
    ttlSec: string;
}
/** Defines a remote API HTTP endpoint */
export interface RemoteApiHttpEndpoint {
    /** URL path of the endpoint; could be fixed or parameterized */
    path: string;
    /** HTTP methods allowed for requests to this endpoint */
    methods: RemoteApiHttpEndpoint_HttpRequestMethod[];
    /** Parameters allowed for requests to this endpoint; required if path is parameterized */
    parameters: RemoteApiHttpRequestParameter[];
    /** Metadata */
    metadata: RemoteApiEndpointMetadata | undefined;
    /** ID used by clients to refer to this endpoint */
    refId: string;
    /** Type of the endpoint */
    type: RemoteApiEndpointType;
    /** Serialized protobuf descriptor containing request and response types */
    protoDescriptor: Uint8Array;
    /** (only for PROTO endpoints) Request proto message type name */
    requestType: string;
    /** (only for PROTO endpoints) Response proto message type name */
    responseType: string;
    /** (only for internal API endpoints) Whether the API uses internal proxy to get user location */
    usesLocationProxy: boolean;
    /** Caching config */
    cachingConfig: RemoteApiCachingConfig | undefined;
    /** (only for internal API endpoints) User location use case */
    userLocationUseCase: UserLocationUseCase;
    /** Endpoint documentation link (optional) */
    documentationLink: string;
    /** Endpoint use case description (optional) */
    description: string;
    /** (only for PROTO endpoints) Used to configure visibility/macros of response proto fields */
    responseParameters: RemoteApiHttpResponseParameter[];
    /**
     * Validate body through Abuse Language Detection service before making request
     *
     * @deprecated
     */
    reqAldRequestValidation: boolean;
    /**
     * Validate body through Abuse Language Detection service before returning response
     *
     * @deprecated
     */
    reqAldResponseValidation: boolean;
    /** Which ALD context window to use for validation */
    aldContextWindow: string;
    /** Which types of content in the request to run through ALD */
    aldRequestConfigs: AldRequestValidationConfig[];
    /** Which types of content in the response to run through ALD */
    aldResponseConfigs: AldResponseValidationConfig[];
}
/** Possible HTTP request method on an endpoint */
export declare enum RemoteApiHttpEndpoint_HttpRequestMethod {
    /** METHOD_UNSET - Undefined method */
    METHOD_UNSET = "METHOD_UNSET",
    /** GET - HTTP GET */
    GET = "GET",
    /** POST - HTTP POST */
    POST = "POST",
    /** PUT - HTTP PUT */
    PUT = "PUT",
    /** DELETE - HTTP DELETE */
    DELETE = "DELETE",
    /** PATCH - HTTP PATCH */
    PATCH = "PATCH",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function remoteApiHttpEndpoint_HttpRequestMethodFromJSON(object: any): RemoteApiHttpEndpoint_HttpRequestMethod;
export declare function remoteApiHttpEndpoint_HttpRequestMethodToNumber(object: RemoteApiHttpEndpoint_HttpRequestMethod): number;
/** Defines a remote API gRPC endpoint */
export interface RemoteApiGrpcEndpoint {
    /** Symbol of target method in the format of package.service.method */
    methodSymbol: string;
    /** ID used by clients to refer to this endpoint */
    refId: string;
    /** Request proto message type name */
    requestType: string;
    /** Response proto message type name */
    responseType: string;
    /** (only for internal API endpoints) Whether the API uses internal proxy to get user location */
    usesLocationProxy: boolean;
    /** (only for internal API endpoints) User location use case */
    userLocationUseCase: UserLocationUseCase;
    /** Endpoint documentation link (optional) */
    documentationLink: string;
    /** Endpoint use case description (optional) */
    description: string;
    /** Used to configure visibility/macros of response proto fields */
    responseParameters: RemoteApiGrpcResponseParameter[];
    /** Serialized protobuf descriptor containing request and response types */
    protoDescriptor: Uint8Array;
    /** Request parameters for this gRPC endpoint (used to configure macros/optional fields) */
    requestParameters: RemoteApiGrpcRequestParameter[];
}
/** Represents names of fields in a proto response, as well as an optional macro value */
export interface RemoteApiGrpcResponseParameter {
    /** Unique name of the parameter */
    name: string;
    /** Whether or not we want to expose this parameter in the final API response to user */
    hidden: boolean;
    /** Specific macro values indicate certain parameters and types that we want to map this proto field to. */
    macroValue: string;
}
/** Defines how a parameter is injected into an gRPC request */
export interface RemoteApiGrpcRequestParameter {
    /** Unique name of the parameter */
    name: string;
    /** Is parameter optional */
    optional: boolean;
    /**
     * Default value if the parameter is not set. Useful for "standard" headers like content-type
     * and other similar cases. If a default value is provided, the parameter will be sent with every request.
     * Required for constant parameters.
     */
    defaultValue: string;
    /**
     * Constant parameters have the same predefined value for all requests and
     * are always set by the proxy. Not allowed to be overridden by the caller.
     */
    constant: boolean;
}
/** Defines OAuth2-related configuration for a remote API */
export interface RemoteApiOAuth2Config {
    /** OAuth2 client identifier: https://tools.ietf.org/html/rfc6749#section-2.2 */
    clientId: string;
    /** OAuth2 grant type required for the remote API */
    grantType: RemoteApiOAuth2Config_GrantType;
    /** https://tools.ietf.org/html/rfc6749#section-3.1 */
    authorizationUrl: string;
    /** https://tools.ietf.org/html/rfc6749#section-3.2 */
    tokenUrl: string;
    /** https://tools.ietf.org/html/rfc6749#section-3.3 */
    scope: string;
    /** https://datatracker.ietf.org/doc/html/rfc6749#section-2.3.1 */
    clientSecret: string;
}
/** OAuth2 grant types supported by the remote-service feature */
export declare enum RemoteApiOAuth2Config_GrantType {
    /** GRANT_TYPE_UNSET - Undefined grant type */
    GRANT_TYPE_UNSET = "GRANT_TYPE_UNSET",
    /** AUTHORIZATION_CODE - https://datatracker.ietf.org/doc/html/rfc6749#section-4.1 */
    AUTHORIZATION_CODE = "AUTHORIZATION_CODE",
    /** AUTHORIZATION_CODE_WITH_PKCE - https://tools.ietf.org/html/rfc7636 */
    AUTHORIZATION_CODE_WITH_PKCE = "AUTHORIZATION_CODE_WITH_PKCE",
    /** IMPLICIT - https://tools.ietf.org/html/rfc6749#section-4.2 */
    IMPLICIT = "IMPLICIT",
    /** CLIENT_CREDENTIALS - https://tools.ietf.org/html/rfc6749#section-4.4 */
    CLIENT_CREDENTIALS = "CLIENT_CREDENTIALS",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function remoteApiOAuth2Config_GrantTypeFromJSON(object: any): RemoteApiOAuth2Config_GrantType;
export declare function remoteApiOAuth2Config_GrantTypeToNumber(object: RemoteApiOAuth2Config_GrantType): number;
/** Defines security-related configuration of a remote API */
export interface RemoteApiSecurityConfig {
    /** Security scheme of the remote API */
    securityScheme: RemoteApiSecurityConfig_SecurityScheme;
    configs?: {
        $case: "apiKeyParam";
        apiKeyParam: RemoteApiHttpRequestParameter;
    } | {
        $case: "oauth2Config";
        oauth2Config: RemoteApiOAuth2Config;
    } | {
        $case: "apiKeyConfig";
        apiKeyConfig: RemoteApiKeyConfig;
    } | undefined;
}
/** Possible security schemes for a remote API */
export declare enum RemoteApiSecurityConfig_SecurityScheme {
    /** SCHEME_UNSET - Undefined scheme */
    SCHEME_UNSET = "SCHEME_UNSET",
    /** NONE - No authentication is required */
    NONE = "NONE",
    /** SNAP_TOKEN - Internal snap services using snap token */
    SNAP_TOKEN = "SNAP_TOKEN",
    /** API_KEY - API that requires an api key */
    API_KEY = "API_KEY",
    /** OAUTH2 - API that requires OAuth2 */
    OAUTH2 = "OAUTH2",
    UNRECOGNIZED = "UNRECOGNIZED"
}
export declare function remoteApiSecurityConfig_SecuritySchemeFromJSON(object: any): RemoteApiSecurityConfig_SecurityScheme;
export declare function remoteApiSecurityConfig_SecuritySchemeToNumber(object: RemoteApiSecurityConfig_SecurityScheme): number;
/** Defines an API key-based security config */
export interface RemoteApiKeyConfig {
    /** Parameters through which secrets are provided to the API */
    params: RemoteApiHttpRequestParameter[];
    /** Secret values fetched from storage, keyed by param name */
    secretValues: {
        [key: string]: string;
    };
}
export interface RemoteApiKeyConfig_SecretValuesEntry {
    key: string;
    value: string;
}
/** Remote API spec metadata for internal usage */
export interface RemoteApiSpecMetadata {
    /** Human-readable name of the spec */
    name: string;
    /** Who created the spec (email) */
    author: string;
    /** When the spec was created (UTC timestamp) */
    creationTimeSec: string;
    /** When the spec was last edited (UTC timestamp) */
    lastEditTimeSec: string;
    /** Who last edited the spec (email) */
    lastEditor: string;
    /** When the spec was last reviewed (UTC timestamp) */
    reviewTimeSec: string;
    /** Who last reviewed the spec (email) */
    reviewer: string;
    /**
     * ID of the secret that contains they API key(s) or other authentication data
     * in Spookey or another secret storage
     */
    secretId: string;
    /** ID of the API spec, from which this one was derived (if any) */
    derivedFromSpecId: string;
    /** Where was this API spec created from */
    createdFrom: CreatedFrom;
    /** URL containing the icon of the API (e.g. in Bolt) */
    iconUrl: string;
    /** Company or person providing the API */
    providerName: string;
    /** Textual description for the API that may include links to documentation, etc. */
    description: string;
    /** Link to API documentation */
    documentationUrl: string;
    /** Link to internal quip documenting the API */
    internalApiQuipUrl: string;
    /** Spec version */
    version: string;
}
/** Defines a remote service with a list of endpoints and a single security configuration */
export interface RemoteApiSpec {
    /** ID of the API spec */
    id: string;
    /** List of HTTP endpoints allowed by this API spec */
    endpoints: RemoteApiHttpEndpoint[];
    /** Security configuration of this API spec */
    securityConfig: RemoteApiSecurityConfig | undefined;
    /** Hostname or hostname and port in format of host:port */
    host: string;
    /** Defines if secured connection (HTTPS) must be forced */
    tlsRequired: boolean;
    /** Specifies caller's max request size in bytes for any of defined endpoints (optional value) */
    maxRequestSizeBytes: number;
    /** Specifies calle's max response size in bytes for any of defined endpoints (optional value) */
    maxResponseSizeBytes: number;
    /** Specifies calle's max response time in millis for any of defined endpoints (optional value) */
    maxResponseTimeMillis: number;
    /** Approval state of the spec */
    approvalState: SpecApprovalState;
    /** Visibility of the spec */
    visibility: SpecVisibility;
    /** Metadata */
    metadata: RemoteApiSpecMetadata | undefined;
    /** Target platform of the spec */
    targetPlatforms: TargetPlatform[];
    /** List of user IDs that are given visibility to a spec (optional value) */
    customVisibilityUsers: string[];
    /** Whether or not this API actually goes through the remote-api service vs a local client handler (camera kit for example) */
    localOnly: boolean;
    /** Approximate (within 1d) time that the spec was last accessed (UTC timestamp) */
    lastAccessTimeSec: string;
    /** List of permissions. Empty list indicates no permission is granted. */
    restrictedJsApiPermissions: RestrictedJsApiPermission[];
    /** Minimum Lens Studio version that this spec will be shown in. (e.g. "4.10.0.0") */
    minLensStudioVersion: string;
    /** Whether or not this spec is restricted from being used in a sponsored lens */
    sponsoredLensRestricted: boolean;
    /** List of user IDs that are given edit permissions to a spec (optional value) */
    editPermissionUsers: string[];
    /** List of gRPC endpoints allowed by this API spec */
    grpcEndpoints: RemoteApiGrpcEndpoint[];
    /** (CameraKit Only) Snap Kit app ID is a metadata field that associates the spec with camera kit app */
    snapkitAppId: string;
    /** (CameraKit Only) - Whether this API uses the Camera Kit built-in local processor or the processor provided by a Camera Kit partner */
    useBuiltinLocalProcessor: boolean;
    /** An id of organization who own the spec */
    orgId: string;
    /** Whether or not we allow link redirects (needs to be trusted API source) */
    allowRedirects: boolean;
}
/** [Deprecated] Remote API spec set metadata for internal usage (services within Snap) */
export interface RemoteApiSpecSetMetadata {
    /** Human-readable name of the API (e.g. "Weather API") */
    name: string;
    /** URL containing the icon of the API (e.g. in Bolt) */
    iconUrl: string;
    /** Company or person providing the API */
    providerName: string;
    /** Textual description for the API that may include links to documentation, etc. */
    description: string;
    /** Who created the spec set (email) */
    author: string;
    /** When the spec set was created (UTC timestamp) */
    creationTimeSec: string;
    /** When the spec set was last edited (UTC timestamp) */
    lastEditTimeSec: string;
    /** Who last edited the spec set (email) */
    lastEditor: string;
    /** Link to API documentation */
    documentationUrl: string;
    /** Where was this API spec created from */
    createdFrom: CreatedFrom;
}
/** [Deprecated] Defines a remote API as a collection of services that are meant to be used together */
export interface RemoteApiSpecSet {
    /** ID of the spec set */
    id: string;
    /** Service specifications */
    specs: RemoteApiSpec[];
    /** Metadata */
    metadata: RemoteApiSpecSetMetadata | undefined;
    /** Approximate (within 1d) time that the spec was last accessed (UTC timestamp) */
    lastAccessTimeSec: string;
}
export declare const RemoteApiHttpRequestParameter: MessageFns<RemoteApiHttpRequestParameter>;
export declare const RemoteApiHttpResponseParameter: MessageFns<RemoteApiHttpResponseParameter>;
export declare const RemoteApiEndpointMetadata: MessageFns<RemoteApiEndpointMetadata>;
export declare const RemoteApiCachingConfig: MessageFns<RemoteApiCachingConfig>;
export declare const RemoteApiHttpEndpoint: MessageFns<RemoteApiHttpEndpoint>;
export declare const RemoteApiGrpcEndpoint: MessageFns<RemoteApiGrpcEndpoint>;
export declare const RemoteApiGrpcResponseParameter: MessageFns<RemoteApiGrpcResponseParameter>;
export declare const RemoteApiGrpcRequestParameter: MessageFns<RemoteApiGrpcRequestParameter>;
export declare const RemoteApiOAuth2Config: MessageFns<RemoteApiOAuth2Config>;
export declare const RemoteApiSecurityConfig: MessageFns<RemoteApiSecurityConfig>;
export declare const RemoteApiKeyConfig: MessageFns<RemoteApiKeyConfig>;
export declare const RemoteApiKeyConfig_SecretValuesEntry: MessageFns<RemoteApiKeyConfig_SecretValuesEntry>;
export declare const RemoteApiSpecMetadata: MessageFns<RemoteApiSpecMetadata>;
export declare const RemoteApiSpec: MessageFns<RemoteApiSpec>;
export declare const RemoteApiSpecSetMetadata: MessageFns<RemoteApiSpecSetMetadata>;
export declare const RemoteApiSpecSet: MessageFns<RemoteApiSpecSet>;
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
    $case: string;
} ? {
    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
} & {
    $case: T["$case"];
} : 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 interface MessageFns<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}
export {};
//# sourceMappingURL=remote_api_spec.d.ts.map