acrylblends 1.0.4 → 1.0.6

package/plugins/acryl-router/src/core/context.d.ts

@@ -1,443 +0,0 @@
-import { AcrylRequest } from './request.ts';
-import type { Result } from './router.ts';
-import type { Env, FetchEventLike, H, Input, NotFoundHandler, RouterRoute, TypedResponse } from './types.ts';
-import type { ResponseHeader } from './utils/headers.ts';
-import type { ContentfulStatusCode, RedirectStatusCode, StatusCode } from './utils/http-status.ts';
-import type { BaseMime } from './utils/mime.ts';
-import type { InvalidJSONValue, IsAny, JSONParsed, JSONValue } from './utils/types.ts';
-type HeaderRecord = Record<'Content-Type', BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
-/**
- * Data type can be a string, ArrayBuffer, Blob, Uint8Array (buffer), or ReadableStream.
- */
-export type Data = string | ArrayBuffer | Blob | ReadableStream | Uint8Array<ArrayBuffer>;
-/**
- * Interface for the execution context in a web worker or similar environment.
- */
-export interface ExecutionContext {
-    /**
-     * Extends the lifetime of the event callback until the promise is settled.
-     *
-     * @param promise - A promise to wait for.
-     */
-    waitUntil(promise: Promise<unknown>): void;
-    /**
-     * Allows the event to be passed through to subsequent event listeners.
-     */
-    passThroughOnException(): void;
-    /**
-     * For compatibility with Wrangler 4.x.
-     */
-    props: any;
-    /**
-     * For compatibility with Wrangler 4.x.
-     */
-    exports?: any;
-}
-/**
- * Interface for context variable mapping.
- */
-export interface ContextVariableMap {
-}
-/**
- * Interface for context renderer.
- */
-export interface ContextRenderer {
-}
-/**
- * Interface representing a renderer for content.
- *
- * @interface DefaultRenderer
- * @param {string | Promise<string>} content - The content to be rendered, which can be either a string or a Promise resolving to a string.
- * @returns {Response | Promise<Response>} - The response after rendering the content, which can be either a Response or a Promise resolving to a Response.
- */
-interface DefaultRenderer {
-    (content: string | Promise<string>): Response | Promise<Response>;
-}
-/**
- * Renderer type which can either be a ContextRenderer or DefaultRenderer.
- */
-export type Renderer = ContextRenderer extends Function ? ContextRenderer : DefaultRenderer;
-/**
- * Extracts the props for the renderer.
- */
-export type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
-export type Layout<T = Record<string, any>> = (props: T) => any;
-/**
- * Interface for getting context variables.
- *
- * @template E - Environment type.
- */
-interface Get<E extends Env> {
-    <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
-    <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
-}
-/**
- * Interface for setting context variables.
- *
- * @template E - Environment type.
- */
-interface Set<E extends Env> {
-    <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
-    <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
-}
-/**
- * Interface for creating a new response.
- */
-interface NewResponse {
-    (data: Data | null, status?: StatusCode, headers?: HeaderRecord): Response;
-    (data: Data | null, init?: ResponseOrInit): Response;
-}
-/**
- * Interface for responding with a body.
- */
-interface BodyRespond {
-    <T extends Data, U extends ContentfulStatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'body'>;
-    <T extends Data, U extends ContentfulStatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'body'>;
-    <T extends null, U extends StatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, 'body'>;
-    <T extends null, U extends StatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, 'body'>;
-}
-/**
- * Interface for responding with text.
- *
- * @interface TextRespond
- * @template T - The type of the text content.
- * @template U - The type of the status code.
- *
- * @param {T} text - The text content to be included in the response.
- * @param {U} [status] - An optional status code for the response.
- * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
- *
- * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
- */
-interface TextRespond {
-    <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
-    <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'text'>;
-}
-/**
- * Interface for responding with JSON.
- *
- * @interface JSONRespond
- * @template T - The type of the JSON value or simplified unknown type.
- * @template U - The type of the status code.
- *
- * @param {T} object - The JSON object to be included in the response.
- * @param {U} [status] - An optional status code for the response.
- * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
- *
- * @returns {JSONRespondReturn<T, U>} - The response after rendering the JSON object, typed with the provided object and status code types.
- */
-interface JSONRespond {
-    <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
-    <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
-}
-/**
- * @template T - The type of the JSON value or simplified unknown type.
- * @template U - The type of the status code.
- *
- * @returns {Response & TypedResponse<JSONParsed<T>, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
- */
-type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, 'json'>;
-/**
- * Interface representing a function that responds with HTML content.
- *
- * @param html - The HTML content to respond with, which can be a string or a Promise that resolves to a string.
- * @param status - (Optional) The HTTP status code for the response.
- * @param headers - (Optional) A record of headers to include in the response.
- * @param init - (Optional) The response initialization object.
- *
- * @returns A Response object or a Promise that resolves to a Response object.
- */
-interface HTMLRespond {
-    <T extends string | Promise<string>>(html: T, status?: ContentfulStatusCode, headers?: HeaderRecord): T extends string ? Response : Promise<Response>;
-    <T extends string | Promise<string>>(html: T, init?: ResponseOrInit<ContentfulStatusCode>): T extends string ? Response : Promise<Response>;
-}
-/**
- * Options for configuring the context.
- *
- * @template E - Environment type.
- */
-type ContextOptions<E extends Env> = {
-    /**
-     * Bindings for the environment.
-     */
-    env: E['Bindings'];
-    /**
-     * Execution context for the request.
-     */
-    executionCtx?: FetchEventLike | ExecutionContext | undefined;
-    /**
-     * Handler for not found responses.
-     */
-    notFoundHandler?: NotFoundHandler<E>;
-    matchResult?: Result<[H, RouterRoute]>;
-    path?: string;
-};
-interface SetHeadersOptions {
-    append?: boolean;
-}
-interface SetHeaders {
-    (name: 'Content-Type', value?: BaseMime, options?: SetHeadersOptions): void;
-    (name: ResponseHeader, value?: string, options?: SetHeadersOptions): void;
-    (name: string, value?: string, options?: SetHeadersOptions): void;
-}
-type ResponseHeadersInit = [string, string][] | Record<'Content-Type', BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
-interface ResponseInit<T extends StatusCode = StatusCode> {
-    headers?: ResponseHeadersInit;
-    status?: T;
-    statusText?: string;
-}
-type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T> | Response;
-export declare const TEXT_PLAIN = "text/plain; charset=UTF-8";
-export declare class Context<E extends Env = any, P extends string = any, I extends Input = {}> {
-    #private;
-    /**
-     * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
-     *
-     *
-     * @example
-     * ```ts
-     * // Environment object for Cloudflare Workers
-     * app.get('*', async c => {
-     *   const counter = c.env.COUNTER
-     * })
-     * ```
-     */
-    env: E['Bindings'];
-    finalized: boolean;
-    /**
-     * `.error` can get the error object from the middleware if the Handler throws an error.
-     *
-     *
-     * @example
-     * ```ts
-     * app.use('*', async (c, next) => {
-     *   await next()
-     *   if (c.error) {
-     *     // do something...
-     *   }
-     * })
-     * ```
-     */
-    error: Error | undefined;
-    /**
-     * Creates an instance of the Context class.
-     *
-     * @param req - The Request object.
-     * @param options - Optional configuration options for the context.
-     */
-    constructor(req: Request, options?: ContextOptions<E>);
-    /**
-     * `.req` is the instance of {@link AcrylRequest}.
-     */
-    get req(): AcrylRequest<P, I['out']>;
-    /**
-     * The FetchEvent associated with the current request.
-     *
-     * @throws Will throw an error if the context does not have a FetchEvent.
-     */
-    get event(): FetchEventLike;
-    /**
-     * The ExecutionContext associated with the current request.
-     *
-     * @throws Will throw an error if the context does not have an ExecutionContext.
-     */
-    get executionCtx(): ExecutionContext;
-    /**
-     * The Response object for the current request.
-     */
-    get res(): Response;
-    /**
-     * Sets the Response object for the current request.
-     *
-     * @param _res - The Response object to set.
-     */
-    set res(_res: Response | undefined);
-    /**
-     * `.render()` can create a response within a layout.
-     *
-     *
-     * @example
-     * ```ts
-     * app.get('/', (c) => {
-     *   return c.render('Hello!')
-     * })
-     * ```
-     */
-    render: Renderer;
-    /**
-     * Sets the layout for the response.
-     *
-     * @param layout - The layout to set.
-     * @returns The layout function.
-     */
-    setLayout: (layout: Layout<PropsForRenderer & {
-        Layout: Layout;
-    }>) => Layout<PropsForRenderer & {
-        Layout: Layout;
-    }>;
-    /**
-     * Gets the current layout for the response.
-     *
-     * @returns The current layout function.
-     */
-    getLayout: () => Layout<PropsForRenderer & {
-        Layout: Layout;
-    }> | undefined;
-    /**
-     * `.setRenderer()` can set the layout in the custom middleware.
-     *
-     *
-     * @example
-     * ```tsx
-     * app.use('*', async (c, next) => {
-     *   c.setRenderer((content) => {
-     *     return c.html(
-     *       <html>
-     *         <body>
-     *           <p>{content}</p>
-     *         </body>
-     *       </html>
-     *     )
-     *   })
-     *   await next()
-     * })
-     * ```
-     */
-    setRenderer: (renderer: Renderer) => void;
-    /**
-     * `.header()` can set headers.
-     *
-     *
-     * @example
-     * ```ts
-     * app.get('/welcome', (c) => {
-     *   // Set headers
-     *   c.header('X-Message', 'Hello!')
-     *   c.header('Content-Type', 'text/plain')
-     *
-     *   // Append multiple headers using the append option (e.g. Vary)
-     *   c.header('Vary', 'Accept-Encoding', { append: true })
-     *   c.header('Vary', 'User-Agent', { append: true })
-     *
-     *   return c.body('Thank you for coming')
-     * })
-     * ```
-     */
-    header: SetHeaders;
-    status: (status: StatusCode) => void;
-    /**
-     * `.set()` can set the value specified by the key.
-     *
-     *
-     * @example
-     * ```ts
-     * app.use('*', async (c, next) => {
-     *   c.set('message', 'Acryl is hot!!')
-     *   await next()
-     * })
-     * ```
-     */
-    set: Set<IsAny<E> extends true ? {
-        Variables: ContextVariableMap & Record<PropertyKey, any>;
-    } : E>;
-    /**
-     * `.get()` can use the value specified by the key.
-     *
-     *
-     * @example
-     * ```ts
-     * app.get('/', (c) => {
-     *   const message = c.get('message')
-     *   return c.text(`The message is "${message}"`)
-     * })
-     * ```
-     */
-    get: Get<IsAny<E> extends true ? {
-        Variables: ContextVariableMap & Record<PropertyKey, any>;
-    } : E>;
-    /**
-     * `.var` can access the value of a variable.
-     *
-     *
-     * @example
-     * ```ts
-     * const result = c.var.client.oneMethod()
-     * ```
-     */
-    get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
-    newResponse: NewResponse;
-    /**
-     * `.body()` can return the HTTP response.
-     * You can set headers with `.header()` and set HTTP status code with `.status`.
-     * This can also be set in `.text()`, `.json()` and so on.
-     *
-     *
-     * @example
-     * ```ts
-     * app.get('/welcome', (c) => {
-     *   // Set headers
-     *   c.header('X-Message', 'Hello!')
-     *   c.header('Content-Type', 'text/plain')
-     *   // Set HTTP status code
-     *   c.status(201)
-     *
-     *   // Return the response body
-     *   return c.body('Thank you for coming')
-     * })
-     * ```
-     */
-    body: BodyRespond;
-    /**
-     * `.text()` can render text as `Content-Type:text/plain`.
-     *
-     *
-     * @example
-     * ```ts
-     * app.get('/say', (c) => {
-     *   return c.text('Hello!')
-     * })
-     * ```
-     */
-    text: TextRespond;
-    /**
-     * `.json()` can render JSON as `Content-Type:application/json`.
-     *
-     *
-     * @example
-     * ```ts
-     * app.get('/api', (c) => {
-     *   return c.json({ message: 'Hello!' })
-     * })
-     * ```
-     */
-    json: JSONRespond;
-    html: HTMLRespond;
-    /**
-     * `.redirect()` can Redirect, default status code is 302.
-     *
-     *
-     * @example
-     * ```ts
-     * app.get('/redirect', (c) => {
-     *   return c.redirect('/')
-     * })
-     * app.get('/redirect-permanently', (c) => {
-     *   return c.redirect('/', 301)
-     * })
-     * ```
-     */
-    redirect: <T extends RedirectStatusCode = 302>(location: string | URL, status?: T) => Response & TypedResponse<undefined, T, "redirect">;
-    /**
-     * `.notFound()` can return the Not Found Response.
-     *
-     *
-     * @example
-     * ```ts
-     * app.get('/notfound', (c) => {
-     *   return c.notFound()
-     * })
-     * ```
-     */
-    notFound: () => ReturnType<NotFoundHandler>;
-}
-export {};

package/plugins/acryl-router/src/core/helper/accepts/accepts.d.ts

@@ -1,30 +0,0 @@
-import type { Context } from '../../context.ts';
-import type { AcceptHeader } from '../../utils/headers.ts';
-export interface Accept {
-    type: string;
-    params: Record<string, string>;
-    q: number;
-}
-export interface acceptsConfig {
-    header: AcceptHeader;
-    supports: string[];
-    default: string;
-}
-export interface acceptsOptions extends acceptsConfig {
-    match?: (accepts: Accept[], config: acceptsConfig) => string;
-}
-export declare const defaultMatch: (accepts: Accept[], config: acceptsConfig) => string;
-/**
- * Match the accept header with the given options.
- * @example
- * ```ts
- * app.get('/users', (c) => {
- *   const lang = accepts(c, {
- *     header: 'Accept-Language',
- *     supports: ['en', 'zh'],
- *     default: 'en',
- *   })
- * })
- * ```
- */
-export declare const accepts: (c: Context, options: acceptsOptions) => string;

package/plugins/acryl-router/src/core/helper/accepts/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * @module
- * Accepts Helper for Acryl.
- */
-export { accepts } from './accepts.ts';

package/plugins/acryl-router/src/core/helper/conninfo/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * @module
- * ConnInfo Helper for Acryl.
- */
-export type { AddressType, NetAddrInfo, ConnInfo, GetConnInfo } from './types.ts';

package/plugins/acryl-router/src/core/helper/conninfo/types.d.ts

@@ -1,36 +0,0 @@
-import type { Context } from '../../context.ts';
-export type AddressType = 'IPv6' | 'IPv4' | undefined;
-export type NetAddrInfo = {
-    /**
-     * Transport protocol type
-     */
-    transport?: 'tcp' | 'udp';
-    /**
-     * Transport port number
-     */
-    port?: number;
-    address?: string;
-    addressType?: AddressType;
-} & ({
-    /**
-     * Host name such as IP Addr
-     */
-    address: string;
-    /**
-     * Host name type
-     */
-    addressType: AddressType;
-} | {});
-/**
- * HTTP Connection information
- */
-export interface ConnInfo {
-    /**
-     * Remote information
-     */
-    remote: NetAddrInfo;
-}
-/**
- * Helper type
- */
-export type GetConnInfo = (c: Context) => ConnInfo;

package/plugins/acryl-router/src/core/helper/cookie/index.d.ts

@@ -1,25 +0,0 @@
-/**
- * @module
- * Cookie Helper for Acryl.
- */
-import type { Context } from '../../context.ts';
-import type { Cookie, CookieOptions, CookiePrefixOptions, SignedCookie } from '../../utils/cookie.ts';
-import type { BufferSource } from '../../utils/types.ts';
-interface GetCookie {
-    (c: Context, key: string): string | undefined;
-    (c: Context): Cookie;
-    (c: Context, key: string, prefixOptions?: CookiePrefixOptions): string | undefined;
-}
-interface GetSignedCookie {
-    (c: Context, secret: string | BufferSource, key: string): Promise<string | undefined | false>;
-    (c: Context, secret: string | BufferSource): Promise<SignedCookie>;
-    (c: Context, secret: string | BufferSource, key: string, prefixOptions?: CookiePrefixOptions): Promise<string | undefined | false>;
-}
-export declare const getCookie: GetCookie;
-export declare const getSignedCookie: GetSignedCookie;
-export declare const generateCookie: (name: string, value: string, opt?: CookieOptions) => string;
-export declare const setCookie: (c: Context, name: string, value: string, opt?: CookieOptions) => void;
-export declare const generateSignedCookie: (name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<string>;
-export declare const setSignedCookie: (c: Context, name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<void>;
-export declare const deleteCookie: (c: Context, name: string, opt?: CookieOptions) => string | undefined;
-export {};

package/plugins/acryl-router/src/core/helper/css/common.d.ts

@@ -1,59 +0,0 @@
-export declare const PSEUDO_GLOBAL_SELECTOR = ":-acryl-global";
-export declare const isPseudoGlobalSelectorRe: RegExp;
-export declare const DEFAULT_STYLE_ID = "acryl-css";
-export declare const SELECTOR: unique symbol;
-export declare const CLASS_NAME: unique symbol;
-export declare const STYLE_STRING: unique symbol;
-export declare const SELECTORS: unique symbol;
-export declare const EXTERNAL_CLASS_NAMES: unique symbol;
-declare const CSS_ESCAPED: unique symbol;
-export interface CssClassName {
-    [SELECTOR]: string;
-    [CLASS_NAME]: string;
-    [STYLE_STRING]: string;
-    [SELECTORS]: CssClassName[];
-    [EXTERNAL_CLASS_NAMES]: string[];
-}
-export declare const IS_CSS_ESCAPED: unique symbol;
-interface CssEscapedString {
-    [CSS_ESCAPED]: string;
-}
-/**
- * @experimental
- * `rawCssString` is an experimental feature.
- * The API might be changed.
- */
-export declare const rawCssString: (value: string) => CssEscapedString;
-export declare const minify: (css: string) => string;
-type CssVariableBasicType = CssClassName | CssEscapedString | string | number | boolean | null | undefined;
-type CssVariableAsyncType = Promise<CssVariableBasicType>;
-type CssVariableArrayType = (CssVariableBasicType | CssVariableAsyncType)[];
-export type CssVariableType = CssVariableBasicType | CssVariableAsyncType | CssVariableArrayType;
-/**
- * A function that customizes generated CSS class names.
- *
- * @param hash - The default hash-based class name (e.g. `css-1234567890`)
- * @param label - The comment label extracted from the CSS template, may be empty.
- *   Whitespace is trimmed and inner spaces are replaced with hyphens.
- * @param styleString - The minified CSS style string
- * @returns The custom class name to use. Must be a safe CSS identifier;
- *   otherwise, the default hash is used as a fallback.
- */
-export type ClassNameSlug = (hash: string, label: string, styleString: string) => string;
-/**
- * A callback function called when an invalid slug is returned from ClassNameSlug.
- *
- * @param slug - The invalid slug
- */
-export type OnInvalidSlug = (slug: string) => void;
-export declare const buildStyleString: (strings: TemplateStringsArray, values: CssVariableType[]) => [string, string, CssClassName[], string[]];
-export declare const cssCommon: (strings: TemplateStringsArray, values: CssVariableType[], classNameSlug?: ClassNameSlug, onInvalidSlug?: OnInvalidSlug) => CssClassName;
-export declare const cxCommon: (args: (string | boolean | null | undefined | CssClassName)[]) => (string | boolean | null | undefined | CssClassName)[];
-export declare const keyframesCommon: (strings: TemplateStringsArray, values: CssVariableType[], classNameSlug?: ClassNameSlug, onInvalidSlug?: OnInvalidSlug) => CssClassName;
-type ViewTransitionType = {
-    (strings: TemplateStringsArray, values: CssVariableType[], classNameSlug?: ClassNameSlug, onInvalidSlug?: OnInvalidSlug): CssClassName;
-    (content: CssClassName): CssClassName;
-    (): CssClassName;
-};
-export declare const viewTransitionCommon: ViewTransitionType;
-export {};

package/plugins/acryl-router/src/core/helper/css/index.d.ts

@@ -1,80 +0,0 @@
-/**
- * @module
- * css Helper for Acryl.
- */
-import type { HtmlEscapedString } from '../../utils/html.ts';
-import type { ClassNameSlug, CssClassName as CssClassNameCommon, CssVariableType, OnInvalidSlug } from './common.ts';
-export { rawCssString } from './common.ts';
-export type { ClassNameSlug, OnInvalidSlug } from './common.ts';
-type CssClassName = HtmlEscapedString & CssClassNameCommon;
-interface CssType {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>;
-}
-interface CxType {
-    (...args: (CssClassName | Promise<string> | string | boolean | null | undefined)[]): Promise<string>;
-}
-interface KeyframesType {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassNameCommon;
-}
-interface ViewTransitionType {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>;
-    (content: Promise<string>): Promise<string>;
-    (): Promise<string>;
-}
-interface StyleType {
-    (args?: {
-        children?: Promise<string>;
-        nonce?: string;
-    }): HtmlEscapedString;
-}
-/**
- * @experimental
- * `createCssContext` is an experimental feature.
- * The API might be changed.
- *
- * @param options.id - The ID for the style element
- * @param options.classNameSlug - Optional function to customize generated CSS class names
- * @param options.onInvalidSlug - Optional callback function called when an invalid slug is returned from ClassNameSlug
- */
-export declare const createCssContext: ({ id, classNameSlug, onInvalidSlug, }: {
-    id: Readonly<string>;
-    classNameSlug?: ClassNameSlug;
-    onInvalidSlug?: OnInvalidSlug;
-}) => DefaultContextType;
-interface DefaultContextType {
-    css: CssType;
-    cx: CxType;
-    keyframes: KeyframesType;
-    viewTransition: ViewTransitionType;
-    Style: StyleType;
-}
-/**
- * @experimental
- * `css` is an experimental feature.
- * The API might be changed.
- */
-export declare const css: CssType;
-/**
- * @experimental
- * `cx` is an experimental feature.
- * The API might be changed.
- */
-export declare const cx: CxType;
-/**
- * @experimental
- * `keyframes` is an experimental feature.
- * The API might be changed.
- */
-export declare const keyframes: KeyframesType;
-/**
- * @experimental
- * `viewTransition` is an experimental feature.
- * The API might be changed.
- */
-export declare const viewTransition: ViewTransitionType;
-/**
- * @experimental
- * `Style` is an experimental feature.
- * The API might be changed.
- */
-export declare const Style: StyleType;