import * as z from "zod";
export declare const OrgIdSchema: z.ZodString;
export type OrgId = z.infer<typeof OrgIdSchema>;
export declare function OrgId(value: string): OrgId;
export declare const ApiIdSchema: z.ZodString;
export type ApiId = z.infer<typeof ApiIdSchema>;
export declare function ApiId(value: string): ApiId;
export declare const ApiDefinitionIdSchema: z.ZodString;
export type ApiDefinitionId = z.infer<typeof ApiDefinitionIdSchema>;
export declare function ApiDefinitionId(value: string): ApiDefinitionId;
export declare const HttpMethodSchema: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]>;
export type HttpMethod = z.infer<typeof HttpMethodSchema>;
export declare const HttpMethod: {
    readonly Get: "GET";
    readonly Post: "POST";
    readonly Put: "PUT";
    readonly Patch: "PATCH";
    readonly Delete: "DELETE";
    readonly Head: "HEAD";
};
export declare const UrlSchema: z.ZodType<Url>;
export type Url = string & {
    Url: void;
};
export declare function Url(value: string): Url;
export declare const EndpointPathLiteralSchema: z.ZodString;
export type EndpointPathLiteral = z.infer<typeof EndpointPathLiteralSchema>;
export declare function EndpointPathLiteral(value: string): EndpointPathLiteral;
export declare const EndpointIdentifierSchema: z.ZodObject<{
    path: z.ZodString;
    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]>;
    identifierOverride: z.ZodOptional<z.ZodNullable<z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    path: string;
    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
    identifierOverride?: string | null | undefined;
}, {
    path: string;
    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
    identifierOverride?: string | null | undefined;
}>;
export type EndpointIdentifier = z.infer<typeof EndpointIdentifierSchema>;
export type SdkRequest = {
    type: "typescript";
    package: string;
    version: string | undefined;
} | {
    type: "python";
    package: string;
    version: string | undefined;
} | {
    type: "go";
    githubRepo: string;
    version: string | undefined;
} | {
    type: "ruby";
    gem: string;
    version: string | undefined;
} | {
    type: "java";
    group: string;
    artifact: string;
    version: string | undefined;
} | {
    type: "csharp";
    package: string;
    version: string | undefined;
};
export declare const SdkRequestSchema: z.ZodType<SdkRequest>;
export declare const DocsConfigIdSchema: z.ZodString;
export type DocsConfigId = z.infer<typeof DocsConfigIdSchema>;
export declare function DocsConfigId(value: string): DocsConfigId;
export declare const GrpcIdSchema: z.ZodString;
export type GrpcId = z.infer<typeof GrpcIdSchema>;
export declare function GrpcId(value: string): GrpcId;
export declare const PageIdSchema: z.ZodString;
export type PageId = z.infer<typeof PageIdSchema>;
export declare function PageId(value: string): PageId;
export declare const RoleIdSchema: z.ZodString;
export type RoleId = z.infer<typeof RoleIdSchema>;
export declare function RoleId(value: string): RoleId;
export declare const TokenIdSchema: z.ZodString;
export type TokenId = z.infer<typeof TokenIdSchema>;
export declare const VersionIdSchema: z.ZodString;
export type VersionId = z.infer<typeof VersionIdSchema>;
export declare function VersionId(value: string): VersionId;
export declare const LinkTarget: {
    readonly Blank: "_blank";
    readonly Self: "_self";
    readonly Parent: "_parent";
    readonly Top: "_top";
};
export type LinkTarget = (typeof LinkTarget)[keyof typeof LinkTarget];
export declare const GrpcMethod: {
    readonly Unary: "UNARY";
    readonly ClientStream: "CLIENT_STREAM";
    readonly ServerStream: "SERVER_STREAM";
    readonly BidirectionalStream: "BIDIRECTIONAL_STREAM";
};
export type GrpcMethod = (typeof GrpcMethod)[keyof typeof GrpcMethod];
export declare const Availability: {
    readonly Stable: "Stable";
    readonly GenerallyAvailable: "GenerallyAvailable";
    readonly InDevelopment: "InDevelopment";
    readonly PreRelease: "PreRelease";
    readonly Deprecated: "Deprecated";
    readonly Beta: "Beta";
};
export type Availability = (typeof Availability)[keyof typeof Availability];
export declare const SupportedLanguage: {
    readonly Curl: "curl";
    readonly Python: "python";
    readonly Javascript: "javascript";
    readonly Js: "js";
    readonly Node: "node";
    readonly Typescript: "typescript";
    readonly Ts: "ts";
    readonly Go: "go";
    readonly Ruby: "ruby";
    readonly Csharp: "csharp";
    readonly Php: "php";
    readonly Swift: "swift";
    readonly Rust: "rust";
};
export type SupportedLanguage = (typeof SupportedLanguage)[keyof typeof SupportedLanguage];
export declare const HttpSnippetLanguage: {
    readonly Curl: "curl";
    readonly Csharp: "csharp";
    readonly Go: "go";
    readonly Java: "java";
    readonly Javascript: "javascript";
    readonly Php: "php";
    readonly Python: "python";
    readonly Ruby: "ruby";
    readonly Swift: "swift";
    readonly Rust: "rust";
    readonly Typescript: "typescript";
};
export type HttpSnippetLanguage = (typeof HttpSnippetLanguage)[keyof typeof HttpSnippetLanguage];
export interface InvalidDomainErrorBody {
    /** Value the domain should end with (i.e. docs.buildwithfern.com or dev.docs.buildwithfern.com) */
    requiredDomainSuffix: string;
}
export interface AnnouncementConfig {
    /** The text to display in the banner, using markdown. */
    text: string;
}
export type SnippetsByEndpointMethod = Partial<Record<HttpMethod, Snippet[]>>;
export declare const SnippetsByEndpointMethodSchema: z.ZodType<SnippetsByEndpointMethod>;
export interface TypeScriptSdk {
    package: string;
    version: string;
}
export interface PythonSdk {
    package: string;
    version: string;
}
export interface GoSdk {
    githubRepo: string;
    version: string;
}
export interface RubySdk {
    gem: string;
    version: string;
}
export interface CsharpSdk {
    package: string;
    version: string;
}
export interface JavaSdk {
    group: string;
    artifact: string;
    version: string;
}
export interface TypeScriptSnippet {
    sdk: TypeScriptSdk;
    client: string;
}
export interface PythonSnippet {
    sdk: PythonSdk;
    async_client: string;
    sync_client: string;
}
export interface GoSnippet {
    sdk: GoSdk;
    client: string;
}
export interface RubySnippet {
    sdk: RubySdk;
    client: string;
}
export interface CsharpSnippet {
    sdk: CsharpSdk;
    client: string;
}
export interface JavaSnippet {
    sdk: JavaSdk;
    async_client: string;
    sync_client: string;
}
export interface TypeScriptSnippetCode {
    client: string;
}
export interface PythonSnippetCode {
    async_client: string;
    sync_client: string;
}
export interface GoSnippetCode {
    client: string;
}
export interface RubySnippetCode {
    client: string;
}
export interface JavaSnippetCode {
    async_client: string;
    sync_client: string;
}
export interface CsharpSnippetCode {
    client: string;
}
export declare const SdkSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
    type: z.ZodLiteral<"typescript">;
    package: z.ZodString;
    version: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "typescript";
    package: string;
    version: string;
}, {
    type: "typescript";
    package: string;
    version: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"python">;
    package: z.ZodString;
    version: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "python";
    package: string;
    version: string;
}, {
    type: "python";
    package: string;
    version: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"go">;
    githubRepo: z.ZodString;
    version: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "go";
    version: string;
    githubRepo: string;
}, {
    type: "go";
    version: string;
    githubRepo: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"ruby">;
    gem: z.ZodString;
    version: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "ruby";
    version: string;
    gem: string;
}, {
    type: "ruby";
    version: string;
    gem: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"java">;
    group: z.ZodString;
    artifact: z.ZodString;
    version: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "java";
    version: string;
    group: string;
    artifact: string;
}, {
    type: "java";
    version: string;
    group: string;
    artifact: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"csharp">;
    package: z.ZodString;
    version: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "csharp";
    package: string;
    version: string;
}, {
    type: "csharp";
    package: string;
    version: string;
}>]>;
export type Sdk = z.infer<typeof SdkSchema>;
export type Template = unknown;
export type Snippet = Snippet.Typescript | Snippet.Python | Snippet.Java | Snippet.Go | Snippet.Ruby | Snippet.Csharp;
export declare namespace Snippet {
    interface _Base {
        exampleIdentifier: string | undefined;
    }
    export interface Typescript extends TypeScriptSnippet, _Base {
        type: "typescript";
    }
    export interface Python extends PythonSnippet, _Base {
        type: "python";
    }
    export interface Java extends JavaSnippet, _Base {
        type: "java";
    }
    export interface Go extends GoSnippet, _Base {
        type: "go";
    }
    export interface Ruby extends RubySnippet, _Base {
        type: "ruby";
    }
    export interface Csharp extends CsharpSnippet, _Base {
        type: "csharp";
    }
    export {};
}
//# sourceMappingURL=shared.d.ts.map