import { Expressionable, ResourceDefinition } from 'arm-templator';
export interface Capability {
    name?: Expressionable<string>;
}
export interface CassandraKeyspaceCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<CassandraKeyspaceResource>;
}
export interface CassandraKeyspaceResource {
    id: Expressionable<string>;
}
export interface CassandraPartitionKey {
    name?: Expressionable<string>;
}
export interface CassandraSchema {
    clusterKeys?: Expressionable<ClusterKey[]>;
    columns?: Expressionable<Column[]>;
    partitionKeys?: Expressionable<CassandraPartitionKey[]>;
}
export interface CassandraTableCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<CassandraTableResource>;
}
export interface CassandraTableResource {
    defaultTtl?: Expressionable<number>;
    id: Expressionable<string>;
    schema?: Expressionable<CassandraSchema>;
}
export interface ClusterKey {
    name?: Expressionable<string>;
    orderBy?: Expressionable<string>;
}
export interface Column {
    name?: Expressionable<string>;
    type?: Expressionable<string>;
}
export interface CompositePath {
    order?: Expressionable<('Ascending' | 'Descending')>;
    path?: Expressionable<string>;
}
export interface ConflictResolutionPolicy {
    conflictResolutionPath?: Expressionable<string>;
    conflictResolutionProcedure?: Expressionable<string>;
    mode?: Expressionable<('LastWriterWins' | 'Custom')>;
}
export interface ConsistencyPolicy {
    defaultConsistencyLevel: Expressionable<('Eventual' | 'Session' | 'BoundedStaleness' | 'Strong' | 'ConsistentPrefix')>;
    maxIntervalInSeconds?: Expressionable<number>;
    maxStalenessPrefix?: Expressionable<number>;
}
export interface ContainerPartitionKey {
    kind?: Expressionable<('Hash' | 'Range')>;
    paths?: Expressionable<string[]>;
    version?: Expressionable<number>;
}
export interface DatabaseAccountCreateUpdateProperties {
    capabilities?: Expressionable<Capability[]>;
    connectorOffer?: Expressionable<('Small')>;
    consistencyPolicy?: Expressionable<ConsistencyPolicy>;
    databaseAccountOfferType: Expressionable<('Standard')>;
    disableKeyBasedMetadataWriteAccess?: Expressionable<boolean>;
    enableAutomaticFailover?: Expressionable<boolean>;
    enableCassandraConnector?: Expressionable<boolean>;
    enableMultipleWriteLocations?: Expressionable<boolean>;
    ipRangeFilter?: Expressionable<string>;
    isVirtualNetworkFilterEnabled?: Expressionable<boolean>;
    locations: Expressionable<Location[]>;
    virtualNetworkRules?: Expressionable<VirtualNetworkRule[]>;
}
export interface ExcludedPath {
    path?: Expressionable<string>;
}
export interface GremlinDatabaseCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<GremlinDatabaseResource>;
}
export interface GremlinDatabaseResource {
    id: Expressionable<string>;
}
export interface GremlinGraphCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<GremlinGraphResource>;
}
export interface GremlinGraphResource {
    conflictResolutionPolicy?: Expressionable<ConflictResolutionPolicy>;
    defaultTtl?: Expressionable<number>;
    id: Expressionable<string>;
    indexingPolicy?: Expressionable<IndexingPolicy>;
    partitionKey?: Expressionable<ContainerPartitionKey>;
    uniqueKeyPolicy?: Expressionable<UniqueKeyPolicy>;
}
export interface IncludedPath {
    indexes?: Expressionable<Indexes[]>;
    path?: Expressionable<string>;
}
export interface Indexes {
    dataType?: Expressionable<('String' | 'Number' | 'Point' | 'Polygon' | 'LineString' | 'MultiPolygon')>;
    kind?: Expressionable<('Hash' | 'Range' | 'Spatial')>;
    precision?: Expressionable<number>;
}
export interface IndexingPolicy {
    automatic?: Expressionable<boolean>;
    compositeIndexes?: Expressionable<CompositePath[][]>;
    excludedPaths?: Expressionable<ExcludedPath[]>;
    includedPaths?: Expressionable<IncludedPath[]>;
    indexingMode?: Expressionable<('Consistent' | 'Lazy' | 'None')>;
    spatialIndexes?: Expressionable<SpatialSpec[]>;
}
export interface Location {
    failoverPriority?: Expressionable<number>;
    isZoneRedundant?: Expressionable<boolean>;
    locationName?: Expressionable<string>;
    provisioningState?: Expressionable<string>;
}
export interface MongoDBCollectionCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<MongoDBCollectionResource>;
}
export interface MongoDBCollectionResource {
    id: Expressionable<string>;
    indexes?: Expressionable<MongoIndex[]>;
    shardKey?: Expressionable<any>;
}
export interface MongoDBDatabaseCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<MongoDBDatabaseResource>;
}
export interface MongoDBDatabaseResource {
    id: Expressionable<string>;
}
export interface MongoIndex {
    key?: Expressionable<MongoIndexKeys>;
    options?: Expressionable<MongoIndexOptions>;
}
export interface MongoIndexKeys {
    keys?: Expressionable<string[]>;
}
export interface MongoIndexOptions {
    expireAfterSeconds?: Expressionable<number>;
    unique?: Expressionable<boolean>;
}
export interface SpatialSpec {
    path?: Expressionable<string>;
    types?: Expressionable<('Point' | 'LineString' | 'Polygon' | 'MultiPolygon')[]>;
}
export interface SqlContainerCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<SqlContainerResource>;
}
export interface SqlContainerResource {
    conflictResolutionPolicy?: Expressionable<ConflictResolutionPolicy>;
    defaultTtl?: Expressionable<number>;
    id: Expressionable<string>;
    indexingPolicy?: Expressionable<IndexingPolicy>;
    partitionKey?: Expressionable<ContainerPartitionKey>;
    uniqueKeyPolicy?: Expressionable<UniqueKeyPolicy>;
}
export interface SqlDatabaseCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<SqlDatabaseResource>;
}
export interface SqlDatabaseResource {
    id: Expressionable<string>;
}
export interface SqlStoredProcedureCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<SqlStoredProcedureResource>;
}
export interface SqlStoredProcedureResource {
    body?: Expressionable<string>;
    id: Expressionable<string>;
}
export interface SqlTriggerCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<SqlTriggerResource>;
}
export interface SqlTriggerResource {
    body?: Expressionable<string>;
    id: Expressionable<string>;
    triggerOperation?: Expressionable<('All' | 'Create' | 'Update' | 'Delete' | 'Replace')>;
    triggerType?: Expressionable<('Pre' | 'Post')>;
}
export interface SqlUserDefinedFunctionCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<SqlUserDefinedFunctionResource>;
}
export interface SqlUserDefinedFunctionResource {
    body?: Expressionable<string>;
    id: Expressionable<string>;
}
export interface TableCreateUpdateProperties {
    options: Expressionable<any>;
    resource: Expressionable<TableResource>;
}
export interface TableResource {
    id: Expressionable<string>;
}
export interface ThroughputSettingsResource {
    throughput: Expressionable<number>;
}
export interface ThroughputSettingsUpdateProperties {
    resource: Expressionable<ThroughputSettingsResource>;
}
export interface UniqueKey {
    paths?: Expressionable<string[]>;
}
export interface UniqueKeyPolicy {
    uniqueKeys?: Expressionable<UniqueKey[]>;
}
export interface VirtualNetworkRule {
    id?: Expressionable<string>;
    ignoreMissingVNetServiceEndpoint?: Expressionable<boolean>;
}
export declare namespace databaseAccounts {
    interface AdditionalProps {
        kind?: Expressionable<('GlobalDocumentDB' | 'MongoDB' | 'Parse')>;
        tags?: Expressionable<any>;
    }
    type DatabaseAccountsResource = ResourceDefinition<DatabaseAccountCreateUpdateProperties, AdditionalProps>;
    function create(name: Expressionable<string>, properties: DatabaseAccountCreateUpdateProperties, location?: Expressionable<string>, kind?: Expressionable<('GlobalDocumentDB' | 'MongoDB' | 'Parse')>, tags?: Expressionable<any>): DatabaseAccountsResource;
}
export declare namespace databaseAccounts {
    namespace cassandraKeyspaces {
        interface AdditionalProps {
            tags?: Expressionable<any>;
        }
        type CassandraKeyspacesResource = ResourceDefinition<CassandraKeyspaceCreateUpdateProperties, AdditionalProps>;
        function create(name: [Expressionable<string>, Expressionable<string>], properties: CassandraKeyspaceCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): CassandraKeyspacesResource;
    }
}
export declare namespace databaseAccounts {
    namespace cassandraKeyspaces {
        namespace tables {
            interface AdditionalProps {
                tags?: Expressionable<any>;
            }
            type TablesResource = ResourceDefinition<CassandraTableCreateUpdateProperties, AdditionalProps>;
            function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: CassandraTableCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): TablesResource;
        }
    }
}
export declare namespace databaseAccounts {
    namespace cassandraKeyspaces {
        namespace tables {
            namespace throughputSettings {
                interface AdditionalProps {
                    tags?: Expressionable<any>;
                }
                type ThroughputSettingsResource = ResourceDefinition<ThroughputSettingsUpdateProperties, AdditionalProps>;
                function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: ThroughputSettingsUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ThroughputSettingsResource;
            }
        }
    }
}
export declare namespace databaseAccounts {
    namespace cassandraKeyspaces {
        namespace throughputSettings {
            interface AdditionalProps {
                tags?: Expressionable<any>;
            }
            type ThroughputSettingsResource = ResourceDefinition<ThroughputSettingsUpdateProperties, AdditionalProps>;
            function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: ThroughputSettingsUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ThroughputSettingsResource;
        }
    }
}
export declare namespace databaseAccounts {
    namespace gremlinDatabases {
        interface AdditionalProps {
            tags?: Expressionable<any>;
        }
        type GremlinDatabasesResource = ResourceDefinition<GremlinDatabaseCreateUpdateProperties, AdditionalProps>;
        function create(name: [Expressionable<string>, Expressionable<string>], properties: GremlinDatabaseCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): GremlinDatabasesResource;
    }
}
export declare namespace databaseAccounts {
    namespace gremlinDatabases {
        namespace graphs {
            interface AdditionalProps {
                tags?: Expressionable<any>;
            }
            type GraphsResource = ResourceDefinition<GremlinGraphCreateUpdateProperties, AdditionalProps>;
            function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: GremlinGraphCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): GraphsResource;
        }
    }
}
export declare namespace databaseAccounts {
    namespace gremlinDatabases {
        namespace graphs {
            namespace throughputSettings {
                interface AdditionalProps {
                    tags?: Expressionable<any>;
                }
                type ThroughputSettingsResource = ResourceDefinition<ThroughputSettingsUpdateProperties, AdditionalProps>;
                function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: ThroughputSettingsUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ThroughputSettingsResource;
            }
        }
    }
}
export declare namespace databaseAccounts {
    namespace gremlinDatabases {
        namespace throughputSettings {
            interface AdditionalProps {
                tags?: Expressionable<any>;
            }
            type ThroughputSettingsResource = ResourceDefinition<ThroughputSettingsUpdateProperties, AdditionalProps>;
            function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: ThroughputSettingsUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ThroughputSettingsResource;
        }
    }
}
export declare namespace databaseAccounts {
    namespace mongodbDatabases {
        interface AdditionalProps {
            tags?: Expressionable<any>;
        }
        type MongodbDatabasesResource = ResourceDefinition<MongoDBDatabaseCreateUpdateProperties, AdditionalProps>;
        function create(name: [Expressionable<string>, Expressionable<string>], properties: MongoDBDatabaseCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): MongodbDatabasesResource;
    }
}
export declare namespace databaseAccounts {
    namespace mongodbDatabases {
        namespace collections {
            interface AdditionalProps {
                tags?: Expressionable<any>;
            }
            type CollectionsResource = ResourceDefinition<MongoDBCollectionCreateUpdateProperties, AdditionalProps>;
            function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: MongoDBCollectionCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): CollectionsResource;
        }
    }
}
export declare namespace databaseAccounts {
    namespace mongodbDatabases {
        namespace collections {
            namespace throughputSettings {
                interface AdditionalProps {
                    tags?: Expressionable<any>;
                }
                type ThroughputSettingsResource = ResourceDefinition<ThroughputSettingsUpdateProperties, AdditionalProps>;
                function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: ThroughputSettingsUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ThroughputSettingsResource;
            }
        }
    }
}
export declare namespace databaseAccounts {
    namespace mongodbDatabases {
        namespace throughputSettings {
            interface AdditionalProps {
                tags?: Expressionable<any>;
            }
            type ThroughputSettingsResource = ResourceDefinition<ThroughputSettingsUpdateProperties, AdditionalProps>;
            function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: ThroughputSettingsUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ThroughputSettingsResource;
        }
    }
}
export declare namespace databaseAccounts {
    namespace sqlDatabases {
        interface AdditionalProps {
            tags?: Expressionable<any>;
        }
        type SqlDatabasesResource = ResourceDefinition<SqlDatabaseCreateUpdateProperties, AdditionalProps>;
        function create(name: [Expressionable<string>, Expressionable<string>], properties: SqlDatabaseCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): SqlDatabasesResource;
    }
}
export declare namespace databaseAccounts {
    namespace sqlDatabases {
        namespace containers {
            interface AdditionalProps {
                tags?: Expressionable<any>;
            }
            type ContainersResource = ResourceDefinition<SqlContainerCreateUpdateProperties, AdditionalProps>;
            function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: SqlContainerCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ContainersResource;
        }
    }
}
export declare namespace databaseAccounts {
    namespace sqlDatabases {
        namespace containers {
            namespace storedProcedures {
                interface AdditionalProps {
                    tags?: Expressionable<any>;
                }
                type StoredProceduresResource = ResourceDefinition<SqlStoredProcedureCreateUpdateProperties, AdditionalProps>;
                function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: SqlStoredProcedureCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): StoredProceduresResource;
            }
        }
    }
}
export declare namespace databaseAccounts {
    namespace sqlDatabases {
        namespace containers {
            namespace throughputSettings {
                interface AdditionalProps {
                    tags?: Expressionable<any>;
                }
                type ThroughputSettingsResource = ResourceDefinition<ThroughputSettingsUpdateProperties, AdditionalProps>;
                function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: ThroughputSettingsUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ThroughputSettingsResource;
            }
        }
    }
}
export declare namespace databaseAccounts {
    namespace sqlDatabases {
        namespace containers {
            namespace triggers {
                interface AdditionalProps {
                    tags?: Expressionable<any>;
                }
                type TriggersResource = ResourceDefinition<SqlTriggerCreateUpdateProperties, AdditionalProps>;
                function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: SqlTriggerCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): TriggersResource;
            }
        }
    }
}
export declare namespace databaseAccounts {
    namespace sqlDatabases {
        namespace containers {
            namespace userDefinedFunctions {
                interface AdditionalProps {
                    tags?: Expressionable<any>;
                }
                type UserDefinedFunctionsResource = ResourceDefinition<SqlUserDefinedFunctionCreateUpdateProperties, AdditionalProps>;
                function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: SqlUserDefinedFunctionCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): UserDefinedFunctionsResource;
            }
        }
    }
}
export declare namespace databaseAccounts {
    namespace sqlDatabases {
        namespace throughputSettings {
            interface AdditionalProps {
                tags?: Expressionable<any>;
            }
            type ThroughputSettingsResource = ResourceDefinition<ThroughputSettingsUpdateProperties, AdditionalProps>;
            function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: ThroughputSettingsUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ThroughputSettingsResource;
        }
    }
}
export declare namespace databaseAccounts {
    namespace tables {
        interface AdditionalProps {
            tags?: Expressionable<any>;
        }
        type TablesResource = ResourceDefinition<TableCreateUpdateProperties, AdditionalProps>;
        function create(name: [Expressionable<string>, Expressionable<string>], properties: TableCreateUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): TablesResource;
    }
}
export declare namespace databaseAccounts {
    namespace tables {
        namespace throughputSettings {
            interface AdditionalProps {
                tags?: Expressionable<any>;
            }
            type ThroughputSettingsResource = ResourceDefinition<ThroughputSettingsUpdateProperties, AdditionalProps>;
            function create(name: [Expressionable<string>, Expressionable<string>, Expressionable<string>], properties: ThroughputSettingsUpdateProperties, location?: Expressionable<string>, tags?: Expressionable<any>): ThroughputSettingsResource;
        }
    }
}