@livestore/sync-s2 0.0.0-snapshot-446f5de211c4578498f20693bd2998869be3e796

package/dist/http-client-generated.d.ts

@@ -0,0 +1,1477 @@
+import { Effect, type HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, type ParseResult, Schema as S } from '@livestore/utils/effect';
+declare const ListAccessTokensParams_base: S.Struct<{
+    prefix: S.optionalWith<typeof S.String, {
+        nullable: true;
+        default: () => "";
+    }>;
+    start_after: S.optionalWith<typeof S.String, {
+        nullable: true;
+        default: () => "";
+    }>;
+    limit: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+        nullable: true;
+        default: () => 1000;
+    }>;
+}>;
+export declare class ListAccessTokensParams extends ListAccessTokensParams_base {
+}
+declare const ResourceSet_base: S.Union<[S.Struct<{
+    /**
+     * Match only the resource with this exact name.
+     * Use an empty string to match no resources.
+     */
+    exact: typeof S.String;
+}>, S.Struct<{
+    /**
+     * Match all resources that start with this prefix.
+     * Use an empty string to match all resource.
+     */
+    prefix: typeof S.String;
+}>]>;
+export declare class ResourceSet extends ResourceSet_base {
+}
+declare const ReadWritePermissions_base: S.Class<ReadWritePermissions, {
+    /**
+     * Read permission.
+     */
+    read: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+        default: () => false;
+    }>;
+    /**
+     * Write permission.
+     */
+    write: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+        default: () => false;
+    }>;
+}, S.Struct.Encoded<{
+    /**
+     * Read permission.
+     */
+    read: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+        default: () => false;
+    }>;
+    /**
+     * Write permission.
+     */
+    write: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+        default: () => false;
+    }>;
+}>, never, {
+    readonly read?: boolean;
+} & {
+    readonly write?: boolean;
+}, {}, {}>;
+export declare class ReadWritePermissions extends ReadWritePermissions_base {
+}
+declare const PermittedOperationGroups_base: S.Class<PermittedOperationGroups, {
+    account: S.optionalWith<typeof ReadWritePermissions, {
+        nullable: true;
+    }>;
+    basin: S.optionalWith<typeof ReadWritePermissions, {
+        nullable: true;
+    }>;
+    stream: S.optionalWith<typeof ReadWritePermissions, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    account: S.optionalWith<typeof ReadWritePermissions, {
+        nullable: true;
+    }>;
+    basin: S.optionalWith<typeof ReadWritePermissions, {
+        nullable: true;
+    }>;
+    stream: S.optionalWith<typeof ReadWritePermissions, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly account?: ReadWritePermissions | undefined;
+} & {
+    readonly basin?: ReadWritePermissions | undefined;
+} & {
+    readonly stream?: ReadWritePermissions | undefined;
+}, {}, {}>;
+export declare class PermittedOperationGroups extends PermittedOperationGroups_base {
+}
+declare const Operation_base: S.Literal<["list-basins", "create-basin", "delete-basin", "reconfigure-basin", "get-basin-config", "issue-access-token", "revoke-access-token", "list-access-tokens", "list-streams", "create-stream", "delete-stream", "get-stream-config", "reconfigure-stream", "check-tail", "append", "read", "trim", "fence", "account-metrics", "basin-metrics", "stream-metrics"]>;
+export declare class Operation extends Operation_base {
+}
+declare const AccessTokenScope_base: S.Class<AccessTokenScope, {
+    access_tokens: S.optionalWith<typeof ResourceSet, {
+        nullable: true;
+    }>;
+    basins: S.optionalWith<typeof ResourceSet, {
+        nullable: true;
+    }>;
+    op_groups: S.optionalWith<typeof PermittedOperationGroups, {
+        nullable: true;
+    }>;
+    /**
+     * Operations allowed for the token.
+     * A union of allowed operations and groups is used as an effective set of allowed operations.
+     */
+    ops: S.optionalWith<S.Array$<typeof Operation>, {
+        nullable: true;
+    }>;
+    streams: S.optionalWith<typeof ResourceSet, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    access_tokens: S.optionalWith<typeof ResourceSet, {
+        nullable: true;
+    }>;
+    basins: S.optionalWith<typeof ResourceSet, {
+        nullable: true;
+    }>;
+    op_groups: S.optionalWith<typeof PermittedOperationGroups, {
+        nullable: true;
+    }>;
+    /**
+     * Operations allowed for the token.
+     * A union of allowed operations and groups is used as an effective set of allowed operations.
+     */
+    ops: S.optionalWith<S.Array$<typeof Operation>, {
+        nullable: true;
+    }>;
+    streams: S.optionalWith<typeof ResourceSet, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly access_tokens?: {
+        readonly exact: string;
+    } | {
+        readonly prefix: string;
+    } | undefined;
+} & {
+    readonly basins?: {
+        readonly exact: string;
+    } | {
+        readonly prefix: string;
+    } | undefined;
+} & {
+    readonly op_groups?: PermittedOperationGroups | undefined;
+} & {
+    readonly ops?: readonly ("read" | "list-basins" | "create-basin" | "delete-basin" | "reconfigure-basin" | "get-basin-config" | "issue-access-token" | "revoke-access-token" | "list-access-tokens" | "list-streams" | "create-stream" | "delete-stream" | "get-stream-config" | "reconfigure-stream" | "check-tail" | "append" | "trim" | "fence" | "account-metrics" | "basin-metrics" | "stream-metrics")[] | undefined;
+} & {
+    readonly streams?: {
+        readonly exact: string;
+    } | {
+        readonly prefix: string;
+    } | undefined;
+}, {}, {}>;
+export declare class AccessTokenScope extends AccessTokenScope_base {
+}
+declare const AccessTokenInfo_base: S.Class<AccessTokenInfo, {
+    /**
+     * Namespace streams based on the configured stream-level scope, which must be a prefix.
+     * Stream name arguments will be automatically prefixed, and the prefix will be stripped when listing streams.
+     */
+    auto_prefix_streams: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+        default: () => false;
+    }>;
+    /**
+     * Expiration time in ISO 8601 format.
+     * If not set, the expiration will be set to that of the requestor's token.
+     */
+    expires_at: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    /**
+     * Access token ID.
+     * It must be unique to the account and between 1 and 96 bytes in length.
+     */
+    id: typeof S.String;
+    /**
+     * Access token scope.
+     */
+    scope: typeof AccessTokenScope;
+}, S.Struct.Encoded<{
+    /**
+     * Namespace streams based on the configured stream-level scope, which must be a prefix.
+     * Stream name arguments will be automatically prefixed, and the prefix will be stripped when listing streams.
+     */
+    auto_prefix_streams: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+        default: () => false;
+    }>;
+    /**
+     * Expiration time in ISO 8601 format.
+     * If not set, the expiration will be set to that of the requestor's token.
+     */
+    expires_at: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    /**
+     * Access token ID.
+     * It must be unique to the account and between 1 and 96 bytes in length.
+     */
+    id: typeof S.String;
+    /**
+     * Access token scope.
+     */
+    scope: typeof AccessTokenScope;
+}>, never, {
+    readonly id: string;
+} & {
+    readonly scope: AccessTokenScope;
+} & {
+    readonly auto_prefix_streams?: boolean;
+} & {
+    readonly expires_at?: string | undefined;
+}, {}, {}>;
+export declare class AccessTokenInfo extends AccessTokenInfo_base {
+}
+declare const ListAccessTokensResponse_base: S.Class<ListAccessTokensResponse, {
+    /**
+     * Matching access tokens.
+     */
+    access_tokens: S.filter<S.Array$<typeof AccessTokenInfo>>;
+    /**
+     * Indicates that there are more access tokens that match the criteria.
+     */
+    has_more: typeof S.Boolean;
+}, S.Struct.Encoded<{
+    /**
+     * Matching access tokens.
+     */
+    access_tokens: S.filter<S.Array$<typeof AccessTokenInfo>>;
+    /**
+     * Indicates that there are more access tokens that match the criteria.
+     */
+    has_more: typeof S.Boolean;
+}>, never, {
+    readonly access_tokens: readonly AccessTokenInfo[];
+} & {
+    readonly has_more: boolean;
+}, {}, {}>;
+export declare class ListAccessTokensResponse extends ListAccessTokensResponse_base {
+}
+declare const ErrorResponse_base: S.Class<ErrorResponse, {
+    code: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    message: typeof S.String;
+}, S.Struct.Encoded<{
+    code: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    message: typeof S.String;
+}>, never, {
+    readonly message: string;
+} & {
+    readonly code?: string | undefined;
+}, {}, {}>;
+export declare class ErrorResponse extends ErrorResponse_base {
+}
+declare const IssueAccessTokenResponse_base: S.Class<IssueAccessTokenResponse, {
+    /**
+     * Created access token.
+     */
+    access_token: typeof S.String;
+}, S.Struct.Encoded<{
+    /**
+     * Created access token.
+     */
+    access_token: typeof S.String;
+}>, never, {
+    readonly access_token: string;
+}, {}, {}>;
+export declare class IssueAccessTokenResponse extends IssueAccessTokenResponse_base {
+}
+declare const ListBasinsParams_base: S.Struct<{
+    prefix: S.optionalWith<typeof S.String, {
+        nullable: true;
+        default: () => "";
+    }>;
+    start_after: S.optionalWith<typeof S.String, {
+        nullable: true;
+        default: () => "";
+    }>;
+    limit: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+        nullable: true;
+        default: () => 1000;
+    }>;
+}>;
+export declare class ListBasinsParams extends ListBasinsParams_base {
+}
+declare const BasinScope_base: S.Literal<["aws:us-east-1"]>;
+export declare class BasinScope extends BasinScope_base {
+}
+declare const BasinState_base: S.Literal<["active", "creating", "deleting"]>;
+export declare class BasinState extends BasinState_base {
+}
+declare const BasinInfo_base: S.Class<BasinInfo, {
+    /**
+     * Basin name.
+     */
+    name: typeof S.String;
+    /**
+     * Basin scope.
+     */
+    scope: typeof BasinScope;
+    /**
+     * Basin state.
+     */
+    state: typeof BasinState;
+}, S.Struct.Encoded<{
+    /**
+     * Basin name.
+     */
+    name: typeof S.String;
+    /**
+     * Basin scope.
+     */
+    scope: typeof BasinScope;
+    /**
+     * Basin state.
+     */
+    state: typeof BasinState;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly scope: "aws:us-east-1";
+} & {
+    readonly state: "active" | "creating" | "deleting";
+}, {}, {}>;
+export declare class BasinInfo extends BasinInfo_base {
+}
+declare const ListBasinsResponse_base: S.Class<ListBasinsResponse, {
+    /**
+     * Matching basins.
+     */
+    basins: S.filter<S.Array$<typeof BasinInfo>>;
+    /**
+     * Indicates that there are more basins that match the criteria.
+     */
+    has_more: typeof S.Boolean;
+}, S.Struct.Encoded<{
+    /**
+     * Matching basins.
+     */
+    basins: S.filter<S.Array$<typeof BasinInfo>>;
+    /**
+     * Indicates that there are more basins that match the criteria.
+     */
+    has_more: typeof S.Boolean;
+}>, never, {
+    readonly basins: readonly BasinInfo[];
+} & {
+    readonly has_more: boolean;
+}, {}, {}>;
+export declare class ListBasinsResponse extends ListBasinsResponse_base {
+}
+declare const DeleteOnEmptyConfig_base: S.Class<DeleteOnEmptyConfig, {
+    /**
+     * Minimum age in seconds before an empty stream can be deleted.
+     * Set to 0 (default) to disable delete-on-empty (don't delete automatically).
+     */
+    min_age_secs: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    /**
+     * Minimum age in seconds before an empty stream can be deleted.
+     * Set to 0 (default) to disable delete-on-empty (don't delete automatically).
+     */
+    min_age_secs: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly min_age_secs?: number | undefined;
+}, {}, {}>;
+export declare class DeleteOnEmptyConfig extends DeleteOnEmptyConfig_base {
+}
+declare const InfiniteRetention_base: S.Record$<typeof S.String, typeof S.Unknown>;
+export declare class InfiniteRetention extends InfiniteRetention_base {
+}
+declare const RetentionPolicy_base: S.Union<[S.Struct<{
+    /**
+     * Age in seconds for automatic trimming of records older than this threshold.
+     * This must be set to a value greater than 0 seconds.
+     * (While S2 is in public preview, this is capped at 28 days. Let us know if you'd like the cap removed.)
+     */
+    age: S.filter<typeof S.Int>;
+}>, S.Struct<{
+    /**
+     * Retain records unless explicitly trimmed.
+     */
+    infinite: typeof InfiniteRetention;
+}>]>;
+export declare class RetentionPolicy extends RetentionPolicy_base {
+}
+declare const StorageClass_base: S.Literal<["standard", "express"]>;
+export declare class StorageClass extends StorageClass_base {
+}
+declare const TimestampingMode_base: S.Literal<["client-prefer", "client-require", "arrival"]>;
+export declare class TimestampingMode extends TimestampingMode_base {
+}
+declare const TimestampingConfig_base: S.Class<TimestampingConfig, {
+    mode: S.optionalWith<typeof TimestampingMode, {
+        nullable: true;
+    }>;
+    /**
+     * Allow client-specified timestamps to exceed the arrival time.
+     * If this is `false` or not set, client timestamps will be capped at the arrival time.
+     */
+    uncapped: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    mode: S.optionalWith<typeof TimestampingMode, {
+        nullable: true;
+    }>;
+    /**
+     * Allow client-specified timestamps to exceed the arrival time.
+     * If this is `false` or not set, client timestamps will be capped at the arrival time.
+     */
+    uncapped: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly mode?: "client-prefer" | "client-require" | "arrival" | undefined;
+} & {
+    readonly uncapped?: boolean | undefined;
+}, {}, {}>;
+export declare class TimestampingConfig extends TimestampingConfig_base {
+}
+declare const StreamConfig_base: S.Class<StreamConfig, {
+    delete_on_empty: S.optionalWith<typeof DeleteOnEmptyConfig, {
+        nullable: true;
+    }>;
+    retention_policy: S.optionalWith<typeof RetentionPolicy, {
+        nullable: true;
+    }>;
+    storage_class: S.optionalWith<typeof StorageClass, {
+        nullable: true;
+    }>;
+    timestamping: S.optionalWith<typeof TimestampingConfig, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    delete_on_empty: S.optionalWith<typeof DeleteOnEmptyConfig, {
+        nullable: true;
+    }>;
+    retention_policy: S.optionalWith<typeof RetentionPolicy, {
+        nullable: true;
+    }>;
+    storage_class: S.optionalWith<typeof StorageClass, {
+        nullable: true;
+    }>;
+    timestamping: S.optionalWith<typeof TimestampingConfig, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly delete_on_empty?: DeleteOnEmptyConfig | undefined;
+} & {
+    readonly retention_policy?: {
+        readonly age: number;
+    } | {
+        readonly infinite: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} & {
+    readonly storage_class?: "standard" | "express" | undefined;
+} & {
+    readonly timestamping?: TimestampingConfig | undefined;
+}, {}, {}>;
+export declare class StreamConfig extends StreamConfig_base {
+}
+declare const BasinConfig_base: S.Class<BasinConfig, {
+    /**
+     * Create stream on append if it doesn't exist, using the default stream configuration.
+     */
+    create_stream_on_append: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    /**
+     * Create stream on read if it doesn't exist, using the default stream configuration.
+     */
+    create_stream_on_read: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    default_stream_config: S.optionalWith<typeof StreamConfig, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    /**
+     * Create stream on append if it doesn't exist, using the default stream configuration.
+     */
+    create_stream_on_append: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    /**
+     * Create stream on read if it doesn't exist, using the default stream configuration.
+     */
+    create_stream_on_read: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    default_stream_config: S.optionalWith<typeof StreamConfig, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly create_stream_on_append?: boolean | undefined;
+} & {
+    readonly create_stream_on_read?: boolean | undefined;
+} & {
+    readonly default_stream_config?: StreamConfig | undefined;
+}, {}, {}>;
+export declare class BasinConfig extends BasinConfig_base {
+}
+declare const CreateBasinRequest_base: S.Class<CreateBasinRequest, {
+    /**
+     * Basin name which must be globally unique.
+     * It can be between 8 and 48 characters in length, and comprise lowercase letters, numbers and hyphens.
+     * It cannot begin or end with a hyphen.
+     */
+    basin: typeof S.String;
+    config: S.optionalWith<typeof BasinConfig, {
+        nullable: true;
+    }>;
+    /**
+     * Basin scope.
+     */
+    scope: S.optionalWith<typeof BasinScope, {
+        nullable: true;
+        default: () => "aws:us-east-1";
+    }>;
+}, S.Struct.Encoded<{
+    /**
+     * Basin name which must be globally unique.
+     * It can be between 8 and 48 characters in length, and comprise lowercase letters, numbers and hyphens.
+     * It cannot begin or end with a hyphen.
+     */
+    basin: typeof S.String;
+    config: S.optionalWith<typeof BasinConfig, {
+        nullable: true;
+    }>;
+    /**
+     * Basin scope.
+     */
+    scope: S.optionalWith<typeof BasinScope, {
+        nullable: true;
+        default: () => "aws:us-east-1";
+    }>;
+}>, never, {
+    readonly basin: string;
+} & {
+    readonly scope?: "aws:us-east-1";
+} & {
+    readonly config?: BasinConfig | undefined;
+}, {}, {}>;
+export declare class CreateBasinRequest extends CreateBasinRequest_base {
+}
+declare const CreateOrReconfigureBasinParams_base: S.Struct<{
+    's2-request-token': S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class CreateOrReconfigureBasinParams extends CreateOrReconfigureBasinParams_base {
+}
+declare const CreateOrReconfigureBasinRequest_base: typeof S.Null;
+export declare class CreateOrReconfigureBasinRequest extends CreateOrReconfigureBasinRequest_base {
+}
+declare const DeleteOnEmptyReconfiguration_base: S.Class<DeleteOnEmptyReconfiguration, {
+    /**
+     * Minimum age in seconds before an empty stream can be deleted.
+     * Set to 0 to disable delete-on-empty (don't delete automatically).
+     */
+    min_age_secs: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    /**
+     * Minimum age in seconds before an empty stream can be deleted.
+     * Set to 0 to disable delete-on-empty (don't delete automatically).
+     */
+    min_age_secs: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly min_age_secs?: number | undefined;
+}, {}, {}>;
+export declare class DeleteOnEmptyReconfiguration extends DeleteOnEmptyReconfiguration_base {
+}
+declare const TimestampingReconfiguration_base: S.Class<TimestampingReconfiguration, {
+    mode: S.optionalWith<typeof TimestampingMode, {
+        nullable: true;
+    }>;
+    /**
+     * Allow client-specified timestamps to exceed the arrival time.
+     */
+    uncapped: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    mode: S.optionalWith<typeof TimestampingMode, {
+        nullable: true;
+    }>;
+    /**
+     * Allow client-specified timestamps to exceed the arrival time.
+     */
+    uncapped: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly mode?: "client-prefer" | "client-require" | "arrival" | undefined;
+} & {
+    readonly uncapped?: boolean | undefined;
+}, {}, {}>;
+export declare class TimestampingReconfiguration extends TimestampingReconfiguration_base {
+}
+declare const StreamReconfiguration_base: S.Class<StreamReconfiguration, {
+    delete_on_empty: S.optionalWith<typeof DeleteOnEmptyReconfiguration, {
+        nullable: true;
+    }>;
+    retention_policy: S.optionalWith<typeof RetentionPolicy, {
+        nullable: true;
+    }>;
+    storage_class: S.optionalWith<typeof StorageClass, {
+        nullable: true;
+    }>;
+    timestamping: S.optionalWith<typeof TimestampingReconfiguration, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    delete_on_empty: S.optionalWith<typeof DeleteOnEmptyReconfiguration, {
+        nullable: true;
+    }>;
+    retention_policy: S.optionalWith<typeof RetentionPolicy, {
+        nullable: true;
+    }>;
+    storage_class: S.optionalWith<typeof StorageClass, {
+        nullable: true;
+    }>;
+    timestamping: S.optionalWith<typeof TimestampingReconfiguration, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly delete_on_empty?: DeleteOnEmptyReconfiguration | undefined;
+} & {
+    readonly retention_policy?: {
+        readonly age: number;
+    } | {
+        readonly infinite: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} & {
+    readonly storage_class?: "standard" | "express" | undefined;
+} & {
+    readonly timestamping?: TimestampingReconfiguration | undefined;
+}, {}, {}>;
+export declare class StreamReconfiguration extends StreamReconfiguration_base {
+}
+declare const BasinReconfiguration_base: S.Class<BasinReconfiguration, {
+    /**
+     * Create a stream on append.
+     */
+    create_stream_on_append: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    /**
+     * Create a stream on read.
+     */
+    create_stream_on_read: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    default_stream_config: S.optionalWith<typeof StreamReconfiguration, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    /**
+     * Create a stream on append.
+     */
+    create_stream_on_append: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    /**
+     * Create a stream on read.
+     */
+    create_stream_on_read: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    default_stream_config: S.optionalWith<typeof StreamReconfiguration, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly create_stream_on_append?: boolean | undefined;
+} & {
+    readonly create_stream_on_read?: boolean | undefined;
+} & {
+    readonly default_stream_config?: StreamReconfiguration | undefined;
+}, {}, {}>;
+export declare class BasinReconfiguration extends BasinReconfiguration_base {
+}
+declare const AccountMetricSet_base: S.Literal<["active-basins", "account-ops"]>;
+export declare class AccountMetricSet extends AccountMetricSet_base {
+}
+declare const TimeseriesInterval_base: S.Literal<["minute", "hour", "day"]>;
+export declare class TimeseriesInterval extends TimeseriesInterval_base {
+}
+declare const AccountMetricsParams_base: S.Struct<{
+    set: typeof AccountMetricSet;
+    start: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+    end: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+    interval: S.optionalWith<typeof TimeseriesInterval, {
+        nullable: true;
+    }>;
+}>;
+export declare class AccountMetricsParams extends AccountMetricsParams_base {
+}
+declare const MetricUnit_base: S.Literal<["bytes", "operations"]>;
+export declare class MetricUnit extends MetricUnit_base {
+}
+declare const Scalar_base: S.Class<Scalar, {
+    /**
+     * Metric name.
+     */
+    name: typeof S.String;
+    /**
+     * Unit of the metric.
+     */
+    unit: typeof MetricUnit;
+    /**
+     * Metric value.
+     */
+    value: typeof S.Number;
+}, S.Struct.Encoded<{
+    /**
+     * Metric name.
+     */
+    name: typeof S.String;
+    /**
+     * Unit of the metric.
+     */
+    unit: typeof MetricUnit;
+    /**
+     * Metric value.
+     */
+    value: typeof S.Number;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly value: number;
+} & {
+    readonly unit: "bytes" | "operations";
+}, {}, {}>;
+export declare class Scalar extends Scalar_base {
+}
+declare const Accumulation_base: S.Class<Accumulation, {
+    /**
+     * The duration of bucket for the accumulation.
+     */
+    bucket_length: typeof TimeseriesInterval;
+    /**
+     * Timeseries name.
+     */
+    name: typeof S.String;
+    /**
+     * Unit of the metric.
+     */
+    unit: typeof MetricUnit;
+}, S.Struct.Encoded<{
+    /**
+     * The duration of bucket for the accumulation.
+     */
+    bucket_length: typeof TimeseriesInterval;
+    /**
+     * Timeseries name.
+     */
+    name: typeof S.String;
+    /**
+     * Unit of the metric.
+     */
+    unit: typeof MetricUnit;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly unit: "bytes" | "operations";
+} & {
+    readonly bucket_length: "minute" | "hour" | "day";
+}, {}, {}>;
+export declare class Accumulation extends Accumulation_base {
+}
+declare const Gauge_base: S.Class<Gauge, {
+    /**
+     * Timeseries name.
+     */
+    name: typeof S.String;
+    /**
+     * Unit of the metric.
+     */
+    unit: typeof MetricUnit;
+}, S.Struct.Encoded<{
+    /**
+     * Timeseries name.
+     */
+    name: typeof S.String;
+    /**
+     * Unit of the metric.
+     */
+    unit: typeof MetricUnit;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly unit: "bytes" | "operations";
+}, {}, {}>;
+export declare class Gauge extends Gauge_base {
+}
+declare const Label_base: S.Class<Label, {
+    /**
+     * Label name.
+     */
+    name: typeof S.String;
+    /**
+     * Label values.
+     */
+    values: S.Array$<typeof S.String>;
+}, S.Struct.Encoded<{
+    /**
+     * Label name.
+     */
+    name: typeof S.String;
+    /**
+     * Label values.
+     */
+    values: S.Array$<typeof S.String>;
+}>, never, {
+    readonly values: readonly string[];
+} & {
+    readonly name: string;
+}, {}, {}>;
+export declare class Label extends Label_base {
+}
+declare const Metric_base: S.Union<[S.Struct<{
+    /**
+     * Single named value.
+     */
+    scalar: typeof Scalar;
+}>, S.Struct<{
+    /**
+     * Named series of `(timestamp, value)` points representing an accumulation over a specified
+     * bucket.
+     */
+    accumulation: typeof Accumulation;
+}>, S.Struct<{
+    /**
+     * Named series of `(timestamp, value)` points each representing an instantaneous value.
+     */
+    gauge: typeof Gauge;
+}>, S.Struct<{
+    /**
+     * Set of string labels.
+     */
+    label: typeof Label;
+}>]>;
+export declare class Metric extends Metric_base {
+}
+declare const MetricSetResponse_base: S.Class<MetricSetResponse, {
+    /**
+     * Metrics comprising the set.
+     */
+    values: S.Array$<typeof Metric>;
+}, S.Struct.Encoded<{
+    /**
+     * Metrics comprising the set.
+     */
+    values: S.Array$<typeof Metric>;
+}>, never, {
+    readonly values: readonly ({
+        readonly scalar: Scalar;
+    } | {
+        readonly accumulation: Accumulation;
+    } | {
+        readonly gauge: Gauge;
+    } | {
+        readonly label: Label;
+    })[];
+}, {}, {}>;
+export declare class MetricSetResponse extends MetricSetResponse_base {
+}
+declare const BasinMetricSet_base: S.Literal<["storage", "append-ops", "read-ops", "read-throughput", "append-throughput", "basin-ops"]>;
+export declare class BasinMetricSet extends BasinMetricSet_base {
+}
+declare const BasinMetricsParams_base: S.Struct<{
+    set: typeof BasinMetricSet;
+    start: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+    end: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+    interval: S.optionalWith<typeof TimeseriesInterval, {
+        nullable: true;
+    }>;
+}>;
+export declare class BasinMetricsParams extends BasinMetricsParams_base {
+}
+declare const StreamMetricSet_base: S.Literal<["storage"]>;
+export declare class StreamMetricSet extends StreamMetricSet_base {
+}
+declare const StreamMetricsParams_base: S.Struct<{
+    set: typeof StreamMetricSet;
+    start: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+    end: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+    interval: S.optionalWith<typeof TimeseriesInterval, {
+        nullable: true;
+    }>;
+}>;
+export declare class StreamMetricsParams extends StreamMetricsParams_base {
+}
+declare const ListStreamsParams_base: S.Struct<{
+    prefix: S.optionalWith<typeof S.String, {
+        nullable: true;
+        default: () => "";
+    }>;
+    start_after: S.optionalWith<typeof S.String, {
+        nullable: true;
+        default: () => "";
+    }>;
+    limit: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+        nullable: true;
+        default: () => 1000;
+    }>;
+}>;
+export declare class ListStreamsParams extends ListStreamsParams_base {
+}
+declare const StreamInfo_base: S.Class<StreamInfo, {
+    /**
+     * Creation time in ISO 8601 format.
+     */
+    created_at: typeof S.String;
+    /**
+     * Deletion time in ISO 8601 format, if the stream is being deleted.
+     */
+    deleted_at: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    /**
+     * Stream name.
+     */
+    name: typeof S.String;
+}, S.Struct.Encoded<{
+    /**
+     * Creation time in ISO 8601 format.
+     */
+    created_at: typeof S.String;
+    /**
+     * Deletion time in ISO 8601 format, if the stream is being deleted.
+     */
+    deleted_at: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    /**
+     * Stream name.
+     */
+    name: typeof S.String;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly created_at: string;
+} & {
+    readonly deleted_at?: string | undefined;
+}, {}, {}>;
+export declare class StreamInfo extends StreamInfo_base {
+}
+declare const ListStreamsResponse_base: S.Class<ListStreamsResponse, {
+    /**
+     * Indicates that there are more results that match the criteria.
+     */
+    has_more: typeof S.Boolean;
+    /**
+     * Matching streams.
+     */
+    streams: S.filter<S.Array$<typeof StreamInfo>>;
+}, S.Struct.Encoded<{
+    /**
+     * Indicates that there are more results that match the criteria.
+     */
+    has_more: typeof S.Boolean;
+    /**
+     * Matching streams.
+     */
+    streams: S.filter<S.Array$<typeof StreamInfo>>;
+}>, never, {
+    readonly streams: readonly StreamInfo[];
+} & {
+    readonly has_more: boolean;
+}, {}, {}>;
+export declare class ListStreamsResponse extends ListStreamsResponse_base {
+}
+declare const CreateStreamRequest_base: S.Class<CreateStreamRequest, {
+    config: S.optionalWith<typeof StreamConfig, {
+        nullable: true;
+    }>;
+    /**
+     * Stream name that is unique to the basin.
+     * It can be between 1 and 512 bytes in length.
+     */
+    stream: typeof S.String;
+}, S.Struct.Encoded<{
+    config: S.optionalWith<typeof StreamConfig, {
+        nullable: true;
+    }>;
+    /**
+     * Stream name that is unique to the basin.
+     * It can be between 1 and 512 bytes in length.
+     */
+    stream: typeof S.String;
+}>, never, {
+    readonly stream: string;
+} & {
+    readonly config?: StreamConfig | undefined;
+}, {}, {}>;
+export declare class CreateStreamRequest extends CreateStreamRequest_base {
+}
+declare const CreateOrReconfigureStreamParams_base: S.Struct<{
+    's2-request-token': S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class CreateOrReconfigureStreamParams extends CreateOrReconfigureStreamParams_base {
+}
+declare const CreateOrReconfigureStreamRequest_base: S.Union<[typeof S.Null, typeof StreamConfig]>;
+export declare class CreateOrReconfigureStreamRequest extends CreateOrReconfigureStreamRequest_base {
+}
+declare const S2Format_base: S.Literal<["raw", "base64"]>;
+export declare class S2Format extends S2Format_base {
+}
+declare const U64_base: S.filter<typeof S.Int>;
+export declare class U64 extends U64_base {
+}
+declare const ReadParams_base: S.Struct<{
+    's2-format': S.optionalWith<typeof S2Format, {
+        nullable: true;
+    }>;
+    seq_num: S.optionalWith<typeof U64, {
+        nullable: true;
+    }>;
+    timestamp: S.optionalWith<typeof U64, {
+        nullable: true;
+    }>;
+    tail_offset: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+    count: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+    bytes: S.optionalWith<S.filter<typeof S.Int>, {
+        nullable: true;
+    }>;
+    until: S.optionalWith<typeof U64, {
+        nullable: true;
+    }>;
+    clamp: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class ReadParams extends ReadParams_base {
+}
+declare const Header_base: S.filter<S.filter<S.NonEmptyArray<typeof S.String>>>;
+/**
+ * Headers add structured information to a record as name-value pairs.
+ *
+ * The name cannot be empty, with the exception of an S2 command record.
+ */
+export declare class Header extends Header_base {
+}
+declare const SequencedRecord_base: S.Class<SequencedRecord, {
+    /**
+     * Body of the record.
+     */
+    body: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    /**
+     * Series of name-value pairs for this record.
+     */
+    headers: S.optionalWith<S.Array$<typeof Header>, {
+        nullable: true;
+    }>;
+    /**
+     * Sequence number assigned by the service.
+     */
+    seq_num: typeof U64;
+    /**
+     * Timestamp for this record.
+     */
+    timestamp: typeof U64;
+}, S.Struct.Encoded<{
+    /**
+     * Body of the record.
+     */
+    body: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    /**
+     * Series of name-value pairs for this record.
+     */
+    headers: S.optionalWith<S.Array$<typeof Header>, {
+        nullable: true;
+    }>;
+    /**
+     * Sequence number assigned by the service.
+     */
+    seq_num: typeof U64;
+    /**
+     * Timestamp for this record.
+     */
+    timestamp: typeof U64;
+}>, never, {
+    readonly seq_num: number;
+} & {
+    readonly timestamp: number;
+} & {
+    readonly body?: string | undefined;
+} & {
+    readonly headers?: readonly (readonly [string, ...string[]])[] | undefined;
+}, {}, {}>;
+/**
+ * Record that is durably sequenced on a stream.
+ */
+export declare class SequencedRecord extends SequencedRecord_base {
+}
+declare const StreamPosition_base: S.Class<StreamPosition, {
+    /**
+     * Sequence number assigned by the service.
+     */
+    seq_num: S.filter<typeof S.Int>;
+    /**
+     * Timestamp, which may be client-specified or assigned by the service.
+     * If it is assigned by the service, it will represent milliseconds since Unix epoch.
+     */
+    timestamp: S.filter<typeof S.Int>;
+}, S.Struct.Encoded<{
+    /**
+     * Sequence number assigned by the service.
+     */
+    seq_num: S.filter<typeof S.Int>;
+    /**
+     * Timestamp, which may be client-specified or assigned by the service.
+     * If it is assigned by the service, it will represent milliseconds since Unix epoch.
+     */
+    timestamp: S.filter<typeof S.Int>;
+}>, never, {
+    readonly seq_num: number;
+} & {
+    readonly timestamp: number;
+}, {}, {}>;
+/**
+ * Position of a record in a stream.
+ */
+export declare class StreamPosition extends StreamPosition_base {
+}
+declare const ReadBatch_base: S.Class<ReadBatch, {
+    /**
+     * Records that are durably sequenced on the stream, retrieved based on the requested criteria.
+     * This can only be empty in response to a regular (non-SSE) read, if the request cannot be satisfied without violating an explicit limit.
+     */
+    records: S.Array$<typeof SequencedRecord>;
+    tail: S.optionalWith<typeof StreamPosition, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    /**
+     * Records that are durably sequenced on the stream, retrieved based on the requested criteria.
+     * This can only be empty in response to a regular (non-SSE) read, if the request cannot be satisfied without violating an explicit limit.
+     */
+    records: S.Array$<typeof SequencedRecord>;
+    tail: S.optionalWith<typeof StreamPosition, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly records: readonly SequencedRecord[];
+} & {
+    readonly tail?: StreamPosition | undefined;
+}, {}, {}>;
+export declare class ReadBatch extends ReadBatch_base {
+}
+declare const TailResponse_base: S.Class<TailResponse, {
+    /**
+     * Sequence number that will be assigned to the next record on the stream, and timestamp of the last record.
+     */
+    tail: typeof StreamPosition;
+}, S.Struct.Encoded<{
+    /**
+     * Sequence number that will be assigned to the next record on the stream, and timestamp of the last record.
+     */
+    tail: typeof StreamPosition;
+}>, never, {
+    readonly tail: StreamPosition;
+}, {}, {}>;
+export declare class TailResponse extends TailResponse_base {
+}
+declare const AppendParams_base: S.Struct<{
+    's2-format': S.optionalWith<typeof S2Format, {
+        nullable: true;
+    }>;
+}>;
+export declare class AppendParams extends AppendParams_base {
+}
+declare const AppendRecord_base: S.Class<AppendRecord, {
+    /**
+     * Body of the record.
+     */
+    body: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    /**
+     * Series of name-value pairs for this record.
+     */
+    headers: S.optionalWith<S.Array$<typeof Header>, {
+        nullable: true;
+    }>;
+    timestamp: S.optionalWith<typeof U64, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    /**
+     * Body of the record.
+     */
+    body: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    /**
+     * Series of name-value pairs for this record.
+     */
+    headers: S.optionalWith<S.Array$<typeof Header>, {
+        nullable: true;
+    }>;
+    timestamp: S.optionalWith<typeof U64, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly timestamp?: number | undefined;
+} & {
+    readonly body?: string | undefined;
+} & {
+    readonly headers?: readonly (readonly [string, ...string[]])[] | undefined;
+}, {}, {}>;
+/**
+ * Record to be appended to a stream.
+ */
+export declare class AppendRecord extends AppendRecord_base {
+}
+declare const AppendInput_base: S.Class<AppendInput, {
+    /**
+     * Enforce a fencing token, which starts out as an empty string that can be overridden by a `fence` command record.
+     */
+    fencing_token: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    match_seq_num: S.optionalWith<typeof U64, {
+        nullable: true;
+    }>;
+    /**
+     * Batch of records to append atomically, which must contain at least one record, and no more than 1000.
+     * The total size of a batch of records may not exceed 1 MiB of metered bytes.
+     */
+    records: S.Array$<typeof AppendRecord>;
+}, S.Struct.Encoded<{
+    /**
+     * Enforce a fencing token, which starts out as an empty string that can be overridden by a `fence` command record.
+     */
+    fencing_token: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    match_seq_num: S.optionalWith<typeof U64, {
+        nullable: true;
+    }>;
+    /**
+     * Batch of records to append atomically, which must contain at least one record, and no more than 1000.
+     * The total size of a batch of records may not exceed 1 MiB of metered bytes.
+     */
+    records: S.Array$<typeof AppendRecord>;
+}>, never, {
+    readonly records: readonly AppendRecord[];
+} & {
+    readonly fencing_token?: string | undefined;
+} & {
+    readonly match_seq_num?: number | undefined;
+}, {}, {}>;
+/**
+ * Payload of an `append` request.
+ */
+export declare class AppendInput extends AppendInput_base {
+}
+declare const AppendAck_base: S.Class<AppendAck, {
+    /**
+     * Sequence number of the last record that was appended `+ 1`, and timestamp of the last record that was appended.
+     * The difference between `end.seq_num` and `start.seq_num` will be the number of records appended.
+     */
+    end: typeof StreamPosition;
+    /**
+     * Sequence number and timestamp of the first record that was appended.
+     */
+    start: typeof StreamPosition;
+    /**
+     * Sequence number that will be assigned to the next record on the stream, and timestamp of the last record on the stream.
+     * This can be greater than the `end` position in case of concurrent appends.
+     */
+    tail: typeof StreamPosition;
+}, S.Struct.Encoded<{
+    /**
+     * Sequence number of the last record that was appended `+ 1`, and timestamp of the last record that was appended.
+     * The difference between `end.seq_num` and `start.seq_num` will be the number of records appended.
+     */
+    end: typeof StreamPosition;
+    /**
+     * Sequence number and timestamp of the first record that was appended.
+     */
+    start: typeof StreamPosition;
+    /**
+     * Sequence number that will be assigned to the next record on the stream, and timestamp of the last record on the stream.
+     * This can be greater than the `end` position in case of concurrent appends.
+     */
+    tail: typeof StreamPosition;
+}>, never, {
+    readonly start: StreamPosition;
+} & {
+    readonly end: StreamPosition;
+} & {
+    readonly tail: StreamPosition;
+}, {}, {}>;
+/**
+ * Success response to an `append` request.
+ */
+export declare class AppendAck extends AppendAck_base {
+}
+declare const AppendConditionFailed_base: S.Union<[S.Struct<{
+    /**
+     * Fencing token did not match.
+     * The expected fencing token is returned.
+     */
+    fencing_token_mismatch: typeof S.String;
+}>, S.Struct<{
+    /**
+     * Sequence number did not match the tail of the stream.
+     * The expected next sequence number is returned.
+     */
+    seq_num_mismatch: S.filter<typeof S.Int>;
+}>]>;
+/**
+ * Aborted due to a failed condition.
+ */
+export declare class AppendConditionFailed extends AppendConditionFailed_base {
+}
+export declare const make: (httpClient: HttpClient.HttpClient, options?: {
+    readonly transformClient?: ((client: HttpClient.HttpClient) => Effect.Effect<HttpClient.HttpClient>) | undefined;
+}) => Client;
+export interface Client {
+    readonly httpClient: HttpClient.HttpClient;
+    /**
+     * List access tokens.
+     */
+    readonly listAccessTokens: (options?: typeof ListAccessTokensParams.Encoded | undefined) => Effect.Effect<typeof ListAccessTokensResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Issue a new access token.
+     */
+    readonly issueAccessToken: (options: typeof AccessTokenInfo.Encoded) => Effect.Effect<typeof IssueAccessTokenResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Revoke an access token.
+     */
+    readonly revokeAccessToken: (id: string) => Effect.Effect<void, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * List basins.
+     */
+    readonly listBasins: (options?: typeof ListBasinsParams.Encoded | undefined) => Effect.Effect<typeof ListBasinsResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Create a basin.
+     */
+    readonly createBasin: (options: typeof CreateBasinRequest.Encoded) => Effect.Effect<typeof BasinInfo.Type | typeof BasinInfo.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Get basin configuration.
+     */
+    readonly getBasinConfig: (basin: string) => Effect.Effect<typeof BasinConfig.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Create or reconfigure a basin.
+     */
+    readonly createOrReconfigureBasin: (basin: string, options: {
+        readonly params?: typeof CreateOrReconfigureBasinParams.Encoded | undefined;
+        readonly payload: typeof CreateOrReconfigureBasinRequest.Encoded;
+    }) => Effect.Effect<typeof BasinInfo.Type | typeof BasinInfo.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Delete a basin.
+     */
+    readonly deleteBasin: (basin: string) => Effect.Effect<void, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Reconfigure a basin.
+     */
+    readonly reconfigureBasin: (basin: string, options: typeof BasinReconfiguration.Encoded) => Effect.Effect<typeof BasinConfig.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Account-level metrics.
+     */
+    readonly accountMetrics: (options: typeof AccountMetricsParams.Encoded) => Effect.Effect<typeof MetricSetResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Basin-level metrics.
+     */
+    readonly basinMetrics: (basin: string, options: typeof BasinMetricsParams.Encoded) => Effect.Effect<typeof MetricSetResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Stream-level metrics.
+     */
+    readonly streamMetrics: (basin: string, stream: string, options: typeof StreamMetricsParams.Encoded) => Effect.Effect<typeof MetricSetResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * List streams.
+     */
+    readonly listStreams: (options?: typeof ListStreamsParams.Encoded | undefined) => Effect.Effect<typeof ListStreamsResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Create a stream.
+     */
+    readonly createStream: (options: typeof CreateStreamRequest.Encoded) => Effect.Effect<typeof StreamInfo.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Get stream configuration.
+     */
+    readonly getStreamConfig: (stream: string) => Effect.Effect<typeof StreamConfig.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Create or reconfigure a stream.
+     */
+    readonly createOrReconfigureStream: (stream: string, options: {
+        readonly params?: typeof CreateOrReconfigureStreamParams.Encoded | undefined;
+        readonly payload: typeof CreateOrReconfigureStreamRequest.Encoded;
+    }) => Effect.Effect<typeof StreamInfo.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Delete a stream.
+     */
+    readonly deleteStream: (stream: string) => Effect.Effect<void, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Reconfigure a stream.
+     */
+    readonly reconfigureStream: (stream: string, options: typeof StreamReconfiguration.Encoded) => Effect.Effect<typeof StreamConfig.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Read records.
+     */
+    readonly read: (stream: string, options?: typeof ReadParams.Encoded | undefined) => Effect.Effect<typeof ReadBatch.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'TailResponse', typeof TailResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Append records.
+     */
+    readonly append: (stream: string, options: {
+        readonly params?: typeof AppendParams.Encoded | undefined;
+        readonly payload: typeof AppendInput.Encoded;
+    }) => Effect.Effect<typeof AppendAck.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'AppendConditionFailed', typeof AppendConditionFailed.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+    /**
+     * Check the tail.
+     */
+    readonly checkTail: (stream: string) => Effect.Effect<typeof TailResponse.Type, HttpClientError.HttpClientError | ParseResult.ParseError | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type> | ClientError<'ErrorResponse', typeof ErrorResponse.Type>>;
+}
+export interface ClientError<Tag extends string, E> {
+    readonly _tag: Tag;
+    readonly request: HttpClientRequest.HttpClientRequest;
+    readonly response: HttpClientResponse.HttpClientResponse;
+    readonly cause: E;
+}
+export declare const ClientError: <Tag extends string, E>(tag: Tag, cause: E, response: HttpClientResponse.HttpClientResponse) => ClientError<Tag, E>;
+export {};
+//# sourceMappingURL=http-client-generated.d.ts.map