@rockset/cli/lib/generator/swagger-types.d.ts

Official Rockset CLI

export interface SwaggerGenerated {
    swagger: string;
    info: Info;
    host: string;
    tags: Tag[];
    schemes: string[];
    paths: Paths;
    definitions: Definitions;
}
export interface Definitions {
    AddDocumentsRequest: AddDocumentsRequest;
    AddDocumentsResponse: SResponse;
    ApiKey: APIKey;
    AwsAccessKey: AwsAccessKey;
    AwsRole: AwsRole;
    Collection: Collection;
    CollectionStats: CollectionStats;
    CreateApiKeyRequest: CreateAPIKeyRequest;
    CreateApiKeyResponse: Response;
    CreateCollectionRequest: CreateCollectionRequest;
    CreateCollectionResponse: Response;
    CreateIntegrationRequest: CreateIntegrationRequest;
    CreateIntegrationResponse: Response;
    CreateQueryLambdaRequest: CreateQueryLambdaRequest;
    CreateQueryLambdaResponse: Response;
    CreateUserRequest: CreateUserRequest;
    CreateUserResponse: Response;
    CreateWorkspaceRequest: CreateWorkspaceRequest;
    CreateWorkspaceResponse: Response;
    CsvParams: CSVParams;
    DeleteApiKeyResponse: Response;
    DeleteCollectionResponse: Response;
    DeleteDocumentsRequest: DocumentsRequest;
    DeleteDocumentsRequestData: DeleteDocumentsRequestData;
    DeleteDocumentsResponse: SResponse;
    DeleteIntegrationResponse: Response;
    DeleteQueryLambdaResponse: Response;
    DeleteUserResponse: Response;
    DeleteWorkspaceResponse: Response;
    DocumentStatus: DocumentStatus;
    DynamodbIntegration: Integration;
    ErrorModel: ErrorModel;
    EventTimeInfo: EventTimeInfo;
    ExecuteQueryLambdaRequest: ExecuteQueryLambdaRequest;
    FieldMapping: FieldMapping;
    FieldMappingV2: FieldMappingV2;
    FieldMask: FieldMask;
    FieldMaskMask: FieldMaskMask;
    FormatParams: FormatParams;
    GcpServiceAccount: GcpServiceAccount;
    GcsIntegration: GcsIntegration;
    GetCollectionResponse: Response;
    GetIntegrationResponse: GetIntegrationResponse;
    GetQueryLambdaResponse: Response;
    GetWorkspaceResponse: Response;
    InputField: InputField;
    Integration: IntegrationClass;
    KafkaIntegration: KafkaIntegration;
    KinesisIntegration: Integration;
    ListApiKeysResponse: SResponse;
    ListCollectionsResponse: SResponse;
    ListIntegrationsResponse: SResponse;
    ListQueryLambdasResponse: SResponse;
    ListUsersResponse: SResponse;
    ListWorkspacesResponse: SResponse;
    MongoDbIntegration: MongoDBIntegration;
    Organization: Organization;
    OrganizationResponse: Response;
    OutputField: OutputField;
    PatchDocument: PatchDocument;
    PatchDocumentsRequest: DocumentsRequest;
    PatchDocumentsResponse: PatchDocumentsResponse;
    PatchOperation: PatchOperation;
    QueryFieldType: QueryFieldType;
    QueryLambda: QueryLambda;
    QueryLambdaSql: QueryLambdaSQL;
    QueryLambdaStats: QueryLambdaStats;
    QueryParameter: QueryParameter;
    QueryRequest: QueryRequest;
    QueryRequestSql: QueryRequestSQL;
    QueryResponse: QueryResponse;
    QueryResponseStats: QueryResponseStats;
    RedshiftIntegration: RedshiftIntegration;
    S3Integration: Integration;
    SegmentIntegration: SegmentIntegration;
    Source: Source;
    SourceDynamoDb: SourceDynamoDB;
    SourceFileUpload: SourceFileUpload;
    SourceGcs: SourceGcs;
    SourceKafka: SourceKafka;
    SourceKinesis: SourceKinesis;
    SourceMongoDb: SourceMongoDB;
    SourceRedshift: SourceRedshift;
    SourceS3: SourceS3;
    SqlExpression: SQLExpression;
    Status: StatusClass;
    StatusDynamoDb: StatusDynamoDB;
    StatusKafka: StatusKafka;
    StatusKafkaPartition: StatusKafkaPartition;
    StatusMongoDb: StatusMongoDB;
    UpdateQueryLambdaRequest: UpdateQueryLambdaRequest;
    UpdateQueryLambdaResponse: Response;
    User: User;
    Workspace: Workspace;
    XmlParams: XMLParams;
}
export interface AddDocumentsRequest {
    type: PurpleType;
    required: string[];
    properties: AddDocumentsRequestProperties;
}
export interface AddDocumentsRequestProperties {
    data: PuneHedgehog;
}
export interface PuneHedgehog {
    type: PurpleType;
    description: string;
    items?: Args;
    example?: string;
    enum?: string[];
}
export interface Args {
    type: PurpleType;
}
export declare enum PurpleType {
    Array = "array",
    Object = "object",
    String = "string"
}
export interface SResponse {
    type: PurpleType;
    properties: PurpleProperties;
}
export interface PurpleProperties {
    data: Data;
}
export interface Data {
    type: PurpleType;
    description: string;
    items: Kafka;
}
export interface Kafka {
    $ref: string;
}
export interface APIKey {
    type: PurpleType;
    required: string[];
    properties: APIKeyProperties;
    description: string;
}
export interface APIKeyProperties {
    created_at: TartuGecko;
    name: TartuGecko;
    key: TartuGecko;
}
export interface TartuGecko {
    type: PurpleType;
    example?: string;
    description: string;
    pattern?: string;
    enum?: string[];
    items?: Items;
    uniqueItems?: boolean;
}
export interface Items {
    type: PurpleType;
    enum?: string[];
}
export interface AwsAccessKey {
    type: PurpleType;
    required: string[];
    properties: AwsAccessKeyProperties;
}
export interface AwsAccessKeyProperties {
    aws_access_key_id: TartuGecko;
    aws_secret_access_key: TartuGecko;
}
export interface AwsRole {
    type: PurpleType;
    required: string[];
    properties: AwsRoleProperties;
}
export interface AwsRoleProperties {
    aws_role_arn: TartuGecko;
}
export interface Collection {
    type: PurpleType;
    properties: CollectionProperties;
}
export interface CollectionProperties {
    created_at: TartuGecko;
    created_by: TartuGecko;
    name: TartuGecko;
    description: TartuGecko;
    workspace: TartuGecko;
    status: TartuGecko;
    sources: Data;
    stats: HammerfestPonies;
    retention_secs: LivingstoneSouthernWhiteFacedOwl;
    field_mappings: Data;
}
export interface LivingstoneSouthernWhiteFacedOwl {
    type: FluffyType;
    format: Format;
    example?: number;
    description: string;
}
export declare enum Format {
    Double = "double",
    Int32 = "int32",
    Int64 = "int64"
}
export declare enum FluffyType {
    Integer = "integer",
    Number = "number"
}
export interface HammerfestPonies {
    description: string;
    $ref: string;
}
export interface CollectionStats {
    type: PurpleType;
    properties: CollectionStatsProperties;
}
export interface CollectionStatsProperties {
    doc_count: LivingstoneSouthernWhiteFacedOwl;
    total_size: LivingstoneSouthernWhiteFacedOwl;
    fill_progress: LivingstoneSouthernWhiteFacedOwl;
    purged_doc_count: LivingstoneSouthernWhiteFacedOwl;
    purged_doc_size: LivingstoneSouthernWhiteFacedOwl;
    last_updated_ms: LivingstoneSouthernWhiteFacedOwl;
    last_queried_ms: LivingstoneSouthernWhiteFacedOwl;
    bytes_inserted: LivingstoneSouthernWhiteFacedOwl;
    bytes_overwritten: LivingstoneSouthernWhiteFacedOwl;
}
export interface CreateAPIKeyRequest {
    type: PurpleType;
    required: string[];
    properties: CreateAPIKeyRequestProperties;
}
export interface CreateAPIKeyRequestProperties {
    name: TartuGecko;
}
export interface Response {
    type: PurpleType;
    properties: FluffyProperties;
}
export interface FluffyProperties {
    data: HammerfestPonies;
}
export interface CreateCollectionRequest {
    type: PurpleType;
    required: string[];
    properties: CreateCollectionRequestProperties;
}
export interface CreateCollectionRequestProperties {
    name: TartuGecko;
    description: TartuGecko;
    sources: Data;
    retention_secs: LivingstoneSouthernWhiteFacedOwl;
    event_time_info: HammerfestPonies;
    field_mappings: Data;
}
export interface CreateIntegrationRequest {
    type: PurpleType;
    required: string[];
    properties: CreateIntegrationRequestProperties;
}
export interface CreateIntegrationRequestProperties {
    name: TartuGecko;
    description: TartuGecko;
    s3: HammerfestPonies;
    kinesis: HammerfestPonies;
    dynamodb: HammerfestPonies;
    redshift: HammerfestPonies;
    gcs: HammerfestPonies;
    segment: Kafka;
    kafka: Kafka;
    mongodb: HammerfestPonies;
}
export interface CreateQueryLambdaRequest {
    type: PurpleType;
    required: string[];
    properties: CreateQueryLambdaRequestProperties;
}
export interface CreateQueryLambdaRequestProperties {
    name: TartuGecko;
    description: TartuGecko;
    sql: HammerfestPonies;
}
export interface CreateUserRequest {
    type: PurpleType;
    required: string[];
    properties: CreateUserRequestProperties;
}
export interface CreateUserRequestProperties {
    email: TartuGecko;
    roles: TartuGecko;
}
export interface CreateWorkspaceRequest {
    type: PurpleType;
    required: string[];
    properties: CreateWorkspaceRequestProperties;
}
export interface CreateWorkspaceRequestProperties {
    name: TartuGecko;
    description: TartuGecko;
}
export interface CSVParams {
    type: PurpleType;
    properties: CSVParamsProperties;
}
export interface CSVParamsProperties {
    firstLineAsColumnNames: FirstLineAsColumnNames;
    separator: TartuGecko;
    encoding: PuneHedgehog;
    columnNames: PuneHedgehog;
    columnTypes: TartuGecko;
    quoteChar: TartuGecko;
    escapeChar: PuneHedgehog;
}
export interface FirstLineAsColumnNames {
    type: string;
    example: boolean;
    description: string;
}
export interface DocumentsRequest {
    type: PurpleType;
    required: string[];
    properties: PurpleProperties;
}
export interface DeleteDocumentsRequestData {
    type: PurpleType;
    required: string[];
    properties: DeleteDocumentsRequestDataProperties;
}
export interface DeleteDocumentsRequestDataProperties {
    _id: TartuGecko;
}
export interface DocumentStatus {
    type: PurpleType;
    properties: DocumentStatusProperties;
}
export interface DocumentStatusProperties {
    _collection: TartuGecko;
    error: HammerfestPonies;
    _id: TartuGecko;
    status: PuneHedgehog;
    patch_id: PuneHedgehog;
}
export interface Integration {
    type: PurpleType;
    properties: DynamodbIntegrationProperties;
}
export interface DynamodbIntegrationProperties {
    aws_access_key: HammerfestPonies;
    aws_role: HammerfestPonies;
}
export interface ErrorModel {
    type: PurpleType;
    properties: ErrorModelProperties;
    description: string;
}
export interface ErrorModelProperties {
    message: TartuGecko;
    type: PuneHedgehog;
    line: LivingstoneSouthernWhiteFacedOwl;
    column: LivingstoneSouthernWhiteFacedOwl;
    trace_id: TraceID;
}
export interface TraceID {
    type: string;
    description: string;
}
export interface EventTimeInfo {
    type: PurpleType;
    required: string[];
    properties: EventTimeInfoProperties;
}
export interface EventTimeInfoProperties {
    field: TartuGecko;
    format: TartuGecko;
    time_zone: TartuGecko;
}
export interface ExecuteQueryLambdaRequest {
    type: PurpleType;
    properties: ExecuteQueryLambdaRequestProperties;
}
export interface ExecuteQueryLambdaRequestProperties {
    parameters: Data;
    default_row_limit: LivingstoneSouthernWhiteFacedOwl;
    generate_warnings: TraceID;
}
export interface FieldMapping {
    type: PurpleType;
    properties: FieldMappingProperties;
}
export interface FieldMappingProperties {
}
export interface FieldMappingV2 {
    type: PurpleType;
    properties: FieldMappingV2Properties;
}
export interface FieldMappingV2Properties {
    name: PuneHedgehog;
    is_drop_all_fields: FirstLineAsColumnNames;
    input_fields: Data;
    output_field: HammerfestPonies;
}
export interface FieldMask {
    type: PurpleType;
    required: string[];
    properties: FieldMaskProperties;
}
export interface FieldMaskProperties {
    input_path: InputPath;
    mask: Kafka;
}
export interface InputPath {
    type: PurpleType;
    items: Args;
}
export interface FieldMaskMask {
    type: PurpleType;
    required: string[];
    properties: FieldMaskMaskProperties;
    description: string;
}
export interface FieldMaskMaskProperties {
    name: Args;
    args: Args;
}
export interface FormatParams {
    type: PurpleType;
    properties: FormatParamsProperties;
}
export interface FormatParamsProperties {
    json: FirstLineAsColumnNames;
    csv: Kafka;
    xml: Kafka;
}
export interface GcpServiceAccount {
    type: PurpleType;
    required: string[];
    properties: GcpServiceAccountProperties;
}
export interface GcpServiceAccountProperties {
    service_account_key_file_json: TraceID;
}
export interface GcsIntegration {
    type: PurpleType;
    properties: GcsIntegrationProperties;
}
export interface GcsIntegrationProperties {
    gcp_service_account: HammerfestPonies;
}
export interface GetIntegrationResponse {
    type: PurpleType;
    properties: GetIntegrationResponseProperties;
}
export interface GetIntegrationResponseProperties {
    data: HammerfestPonies;
    collections: Collections;
}
export interface Collections {
    type: PurpleType;
    items: Kafka;
}
export interface InputField {
    type: PurpleType;
    properties: InputFieldProperties;
}
export interface InputFieldProperties {
    field_name: PuneHedgehog;
    if_missing: PuneHedgehog;
    is_drop: FirstLineAsColumnNames;
    param: PuneHedgehog;
}
export interface IntegrationClass {
    type: PurpleType;
    required: string[];
    properties: IntegrationProperties;
    description: string;
}
export interface IntegrationProperties {
    name: TartuGecko;
    description: TartuGecko;
    created_by: TartuGecko;
    created_at: TartuGecko;
    s3: HammerfestPonies;
    kinesis: HammerfestPonies;
    dynamodb: HammerfestPonies;
    redshift: HammerfestPonies;
    gcs: HammerfestPonies;
    segment: HammerfestPonies;
    kafka: HammerfestPonies;
    mongodb: HammerfestPonies;
}
export interface KafkaIntegration {
    type: PurpleType;
    required: string[];
    properties: KafkaIntegrationProperties;
}
export interface KafkaIntegrationProperties {
    kafka_topic_names: TartuGecko;
    source_status_by_topic: SourceStatusByTopic;
    kafka_data_format: TartuGecko;
    connection_string: ConnectionString;
}
export interface ConnectionString {
    type: PurpleType;
    description: string;
    readOnly: boolean;
}
export interface SourceStatusByTopic {
    type: PurpleType;
    example: string;
    description: string;
    readOnly: boolean;
    additionalProperties: Kafka;
}
export interface MongoDBIntegration {
    type: PurpleType;
    required: string[];
    properties: MongoDBIntegrationProperties;
}
export interface MongoDBIntegrationProperties {
    connection_uri: TartuGecko;
}
export interface Organization {
    type: PurpleType;
    properties: OrganizationProperties;
    description: string;
}
export interface OrganizationProperties {
    id: PuneHedgehog;
    created_at: PuneHedgehog;
    display_name: PuneHedgehog;
    company_name: PuneHedgehog;
    external_id: PuneHedgehog;
    rockset_user: Args;
    state: PuneHedgehog;
}
export interface OutputField {
    type: PurpleType;
    properties: OutputFieldProperties;
}
export interface OutputFieldProperties {
    field_name: PuneHedgehog;
    value: Value;
    on_error: PuneHedgehog;
}
export interface Value {
    example: string;
    description: string;
    $ref: string;
}
export interface PatchDocument {
    type: PurpleType;
    required: string[];
    properties: PatchDocumentProperties;
}
export interface PatchDocumentProperties {
    _id: TartuGecko;
    patch: Data;
}
export interface PatchDocumentsResponse {
    type: PurpleType;
    required: string[];
    properties: PatchDocumentsResponseProperties;
}
export interface PatchDocumentsResponseProperties {
    data: Collections;
}
export interface PatchOperation {
    type: PurpleType;
    required: string[];
    properties: PatchOperationProperties;
}
export interface PatchOperationProperties {
    op: TartuGecko;
    path: TartuGecko;
    value: TartuGecko;
    from: TraceID;
}
export interface QueryFieldType {
    type: PurpleType;
    required: string[];
    properties: QueryFieldTypeProperties;
}
export interface QueryFieldTypeProperties {
    name: PuneHedgehog;
    type: PuneHedgehog;
}
export interface QueryLambda {
    type: PurpleType;
    properties: QueryLambdaProperties;
}
export interface QueryLambdaProperties {
    workspace: TartuGecko;
    created_by: TartuGecko;
    created_at: TartuGecko;
    name: TartuGecko;
    version: LivingstoneSouthernWhiteFacedOwl;
    description: TartuGecko;
    sql: HammerfestPonies;
    collections: TartuGecko;
    state: TartuGecko;
    stats: HammerfestPonies;
}
export interface QueryLambdaSQL {
    type: PurpleType;
    required: string[];
    properties: QueryLambdaSQLProperties;
}
export interface QueryLambdaSQLProperties {
    query: PuneHedgehog;
    default_parameters: Data;
}
export interface QueryLambdaStats {
    type: PurpleType;
    properties: QueryLambdaStatsProperties;
}
export interface QueryLambdaStatsProperties {
    last_executed: TartuGecko;
    last_executed_by: TartuGecko;
    last_execution_error: TartuGecko;
    last_execution_error_message: TartuGecko;
}
export interface QueryParameter {
    type: PurpleType;
    required: string[];
    properties: QueryParameterProperties;
}
export interface QueryParameterProperties {
    name: PuneHedgehog;
    type: PuneHedgehog;
    value: PuneHedgehog;
}
export interface QueryRequest {
    type: PurpleType;
    properties: QueryRequestProperties;
}
export interface QueryRequestProperties {
    sql: HammerfestPonies;
}
export interface QueryRequestSQL {
    type: PurpleType;
    required: string[];
    properties: QueryRequestSQLProperties;
}
export interface QueryRequestSQLProperties {
    parameters: Data;
    query: TartuGecko;
    default_row_limit: LivingstoneSouthernWhiteFacedOwl;
    generate_warnings: TraceID;
    profiling_enabled: TraceID;
}
export interface QueryResponse {
    type: PurpleType;
    properties: QueryResponseProperties;
}
export interface QueryResponseProperties {
    query_id: TraceID;
    collections: PuneHedgehog;
    results: PuneHedgehog;
    stats: HammerfestPonies;
    warnings: PuneHedgehog;
    column_fields: Data;
}
export interface QueryResponseStats {
    type: PurpleType;
    properties: QueryResponseStatsProperties;
}
export interface QueryResponseStatsProperties {
    elapsed_time_ms: LivingstoneSouthernWhiteFacedOwl;
}
export interface RedshiftIntegration {
    type: PurpleType;
    required: string[];
    properties: RedshiftIntegrationProperties;
}
export interface RedshiftIntegrationProperties {
    aws_access_key: HammerfestPonies;
    username: TartuGecko;
    password: PuneHedgehog;
    host: PuneHedgehog;
    port: LivingstoneSouthernWhiteFacedOwl;
    s3_bucket_path: TartuGecko;
}
export interface SegmentIntegration {
    type: PurpleType;
    properties: SegmentIntegrationProperties;
}
export interface SegmentIntegrationProperties {
    connection_string: ConnectionString;
}
export interface Source {
    type: PurpleType;
    required: string[];
    properties: SourceProperties;
    description: string;
}
export interface SourceProperties {
    integration_name: TartuGecko;
    s3: HammerfestPonies;
    kinesis: HammerfestPonies;
    gcs: HammerfestPonies;
    redshift: HammerfestPonies;
    dynamodb: HammerfestPonies;
    file_upload: HammerfestPonies;
    kafka: HammerfestPonies;
    mongodb: HammerfestPonies;
    status: HammerfestPonies;
    format_params: HammerfestPonies;
}
export interface SourceDynamoDB {
    type: PurpleType;
    required: string[];
    properties: SourceDynamoDBProperties;
}
export interface SourceDynamoDBProperties {
    aws_region: TartuGecko;
    table_name: TartuGecko;
    status: Status;
    rcu: LivingstoneSouthernWhiteFacedOwl;
}
export interface Status {
    description: string;
    readOnly: boolean;
    $ref: string;
}
export interface SourceFileUpload {
    type: PurpleType;
    required: string[];
    properties: SourceFileUploadProperties;
}
export interface SourceFileUploadProperties {
    file_name: PuneHedgehog;
    file_size: LivingstoneSouthernWhiteFacedOwl;
    file_upload_time: PuneHedgehog;
}
export interface SourceGcs {
    type: PurpleType;
    properties: SourceGcsProperties;
}
export interface SourceGcsProperties {
    bucket: TartuGecko;
    prefix: TartuGecko;
}
export interface SourceKafka {
    type: PurpleType;
    required: string[];
    properties: SourceKafkaProperties;
}
export interface SourceKafkaProperties {
    kafka_topic_name: PuneHedgehog;
    status: Status;
}
export interface SourceKinesis {
    type: PurpleType;
    required: string[];
    properties: SourceKinesisProperties;
}
export interface SourceKinesisProperties {
    stream_name: PuneHedgehog;
    aws_region: PuneHedgehog;
}
export interface SourceMongoDB {
    type: PurpleType;
    required: string[];
    properties: SourceMongoDBProperties;
}
export interface SourceMongoDBProperties {
    database_name: TartuGecko;
    collection_name: TartuGecko;
    status: Status;
}
export interface SourceRedshift {
    type: PurpleType;
    required: string[];
    properties: SourceRedshiftProperties;
}
export interface SourceRedshiftProperties {
    database: TartuGecko;
    schema: TartuGecko;
    table_name: TartuGecko;
    incremental_field: TartuGecko;
}
export interface SourceS3 {
    type: PurpleType;
    required: string[];
    properties: SourceS3Properties;
}
export interface SourceS3Properties {
    prefix: PuneHedgehog;
    pattern: PuneHedgehog;
    bucket: PuneHedgehog;
}
export interface SQLExpression {
    type: PurpleType;
    properties: SQLExpressionProperties;
}
export interface SQLExpressionProperties {
    sql: TartuGecko;
}
export interface StatusClass {
    type: PurpleType;
    properties: StatusProperties;
}
export interface StatusProperties {
    state: PuneHedgehog;
    since: PuneHedgehog;
    message: PuneHedgehog;
    last_processed_at: PuneHedgehog;
    last_processed_item: PuneHedgehog;
    total_processed_items: LivingstoneSouthernWhiteFacedOwl;
    last_error_at: PuneHedgehog;
    last_error_item: PuneHedgehog;
    last_error_reason: PuneHedgehog;
    total_error_items: LivingstoneSouthernWhiteFacedOwl;
}
export interface StatusDynamoDB {
    type: PurpleType;
    properties: StatusDynamoDBProperties;
}
export interface StatusDynamoDBProperties {
    scan_start_time: TartuGecko;
    scan_end_time: PuneHedgehog;
    scan_records_processed: LivingstoneSouthernWhiteFacedOwl;
    scan_total_records: LivingstoneSouthernWhiteFacedOwl;
    state: TartuGecko;
    stream_last_processed_at: TartuGecko;
}
export interface StatusKafka {
    type: PurpleType;
    properties: StatusKafkaProperties;
}
export interface StatusKafkaProperties {
    state: PuneHedgehog;
    last_consumed_time: PuneHedgehog;
    num_documents_processed: LivingstoneSouthernWhiteFacedOwl;
}
export interface StatusKafkaPartition {
    type: PurpleType;
    properties: StatusKafkaPartitionProperties;
}
export interface StatusKafkaPartitionProperties {
    partition_number: LivingstoneSouthernWhiteFacedOwl;
    num_documents_processed: LivingstoneSouthernWhiteFacedOwl;
}
export interface StatusMongoDB {
    type: PurpleType;
    properties: StatusMongoDBProperties;
}
export interface StatusMongoDBProperties {
    scan_start_time: PuneHedgehog;
    scan_end_time: TartuGecko;
    scan_records_processed: LivingstoneSouthernWhiteFacedOwl;
    scan_total_records: LivingstoneSouthernWhiteFacedOwl;
    state: PuneHedgehog;
    stream_last_insert_processed_at: PuneHedgehog;
    stream_last_update_processed_at: PuneHedgehog;
    stream_last_delete_processed_at: PuneHedgehog;
    stream_records_inserted: LivingstoneSouthernWhiteFacedOwl;
    stream_records_updated: LivingstoneSouthernWhiteFacedOwl;
    stream_records_deleted: LivingstoneSouthernWhiteFacedOwl;
}
export interface UpdateQueryLambdaRequest {
    type: PurpleType;
    properties: UpdateQueryLambdaRequestProperties;
}
export interface UpdateQueryLambdaRequestProperties {
    description: PuneHedgehog;
    sql: HammerfestPonies;
}
export interface User {
    type: PurpleType;
    required: string[];
    properties: UserProperties;
}
export interface UserProperties {
    created_at: PuneHedgehog;
    email: PuneHedgehog;
    first_name: PuneHedgehog;
    last_name: PuneHedgehog;
    roles: PuneHedgehog;
    state: PuneHedgehog;
    org: Args;
}
export interface Workspace {
    type: PurpleType;
    properties: WorkspaceProperties;
    description: string;
}
export interface WorkspaceProperties {
    created_at: TartuGecko;
    created_by: TartuGecko;
    name: TartuGecko;
    description: TartuGecko;
    collection_count: LivingstoneSouthernWhiteFacedOwl;
}
export interface XMLParams {
    type: PurpleType;
    properties: XMLParamsProperties;
}
export interface XMLParamsProperties {
    root_tag: PuneHedgehog;
    encoding: PuneHedgehog;
    doc_tag: PuneHedgehog;
    value_tag: PuneHedgehog;
    attribute_prefix: PuneHedgehog;
}
export interface Info {
    description: string;
    version: string;
    title: string;
}
export interface Paths {
    '/v1/orgs/self': V1OrgsSelf;
    '/v1/orgs/self/collections': V1OrgsSelf;
    '/v1/orgs/self/integrations': PurpleV1OrgsSelf;
    '/v1/orgs/self/integrations/{integration}': V1OrgsSelfIntegrationsIntegrationClass;
    '/v1/orgs/self/lambdas': V1OrgsSelf;
    '/v1/orgs/self/queries': V1OrgsSelfQueries;
    '/v1/orgs/self/users': PurpleV1OrgsSelf;
    '/v1/orgs/self/users/self': V1OrgsSelf;
    '/v1/orgs/self/users/self/apikeys': PurpleV1OrgsSelf;
    '/v1/orgs/self/users/self/apikeys/{name}': V1OrgsSelfUsersSelfApikeysNameClass;
    '/v1/orgs/self/users/{user}': V1OrgsSelfUsersSelfApikeysNameClass;
    '/v1/orgs/self/users/{user}/apikeys': PurpleV1OrgsSelf;
    '/v1/orgs/self/users/{user}/apikeys/{name}': V1OrgsSelfUsersSelfApikeysNameClass;
    '/v1/orgs/self/ws': PurpleV1OrgsSelf;
    '/v1/orgs/self/ws/{workspace}': V1OrgsSelfIntegrationsIntegrationClass;
    '/v1/orgs/self/ws/{workspace}/collections': PurpleV1OrgsSelf;
    '/v1/orgs/self/ws/{workspace}/collections/{collection}': V1OrgsSelfIntegrationsIntegrationClass;
    '/v1/orgs/self/ws/{workspace}/collections/{collection}/docs': V1OrgsSelfWsWorkspaceCollectionsCollectionDocs;
    '/v1/orgs/self/ws/{workspace}/collections/{collection}/lambdas': V1OrgsSelf;
    '/v1/orgs/self/ws/{workspace}/lambdas': PurpleV1OrgsSelf;
    '/v1/orgs/self/ws/{workspace}/lambdas/{queryLambda}': V1OrgsSelfUsersSelfApikeysNameClass;
    '/v1/orgs/self/ws/{workspace}/lambdas/{queryLambda}/versions': PurpleV1OrgsSelf;
    '/v1/orgs/self/ws/{workspace}/lambdas/{queryLambda}/versions/{version}': PurpleV1OrgsSelf;
    '/v1/orgs/self/ws/{workspace}/ws': V1OrgsSelf;
}
export interface V1OrgsSelf {
    get: Get;
}
export interface Get {
    tags: string[];
    summary: string;
    description: string;
    operationId: string;
    consumes: Consume[];
    produces: Consume[];
    parameters: Parameter[];
    responses: Responses;
}
export declare enum Consume {
    ApplicationJSON = "application/json"
}
export interface Parameter {
    in: In;
    name: string;
    description?: string;
    required: boolean;
    schema?: Kafka;
    type?: ParameterType;
    default?: Default;
    format?: Format;
}
export declare enum Default {
    Commons = "commons"
}
export declare enum In {
    Body = "body",
    Path = "path"
}
export declare enum ParameterType {
    Integer = "integer",
    String = "string"
}
export interface Responses {
    '200': The200;
}
export interface The200 {
    description: string;
    schema: Kafka;
}
export interface PurpleV1OrgsSelf {
    get: Get;
    post: Get;
}
export interface V1OrgsSelfIntegrationsIntegrationClass {
    get: Get;
    delete: Get;
}
export interface V1OrgsSelfQueries {
    post: Get;
}
export interface V1OrgsSelfUsersSelfApikeysNameClass {
    delete: Get;
}
export interface V1OrgsSelfWsWorkspaceCollectionsCollectionDocs {
    post: Get;
    delete: Get;
    patch: Get;
}
export interface Tag {
    name: string;
}