## Overview

The Azure Storage Service connector provides access to the Azure Blob REST API and Azure File REST API, enabling programmatic management of cloud storage resources. It supports operations such as listing containers, uploading and downloading blobs, managing file shares and directories, and performing various administrative operations.

### Key Features

- Manage Azure Blob Storage containers and blobs including list, create, upload, download, and delete operations
- Manage Azure File Storage shares, directories, and files with full CRUD support
- Support for both Shared Access Signature (SAS) and Access Key authentication
- Compatible with Azure Storage Service REST API version 2019-12-12

### Compatibility
|                      |  Version                      |
|----------------------|-------------------------------|
| Ballerina Language   | Ballerina Swan Lake 2201.3.0  |
| Azure Storage Service| 2019-12-12                    |

## Report issues
To report bugs, request new features, start new discussions, view project boards, etc., go to the [Ballerina Extended Library repository](https://github.com/ballerina-platform/ballerina-extended-library)

## Useful links
- Discuss code changes of the Ballerina project in [ballerina-dev@googlegroups.com](mailto:ballerina-dev@googlegroups.com).
- Chat live with us via our [Discord server](https://discord.gg/ballerinalang).
- Post all technical questions on Stack Overflow with the [#ballerina](https://stackoverflow.com/questions/tagged/ballerina) tag


Error

The Azure Storage Service connector provides access to the Azure Blob REST API and Azure File REST API, enabling programmatic management of cloud storage resources. It supports operations such as listing containers, uploading and downloading blobs, managing file shares and directories, and performing various administrative operations.


azure_storage_service

azure_storage_service.blobs

azure_storage_service.files

The Azure Storage Service connector provides access to the Azure Blob REST API and Azure File REST API, enabling programmatic management of cloud storage resources. It supports operations such as listing containers, uploading and downloading blobs, managing file shares and directories, and performing various administrative operations.

client.config

regex

time

file

xmldata

crypto

http

Represents the annotation of a function tool.


@cloud:Expose annotation marks a port that has to be exposed in a custom listener initializer.
```ballerina
public function init(@cloud:Expose int port) {}
```


@cloud:Task annotation to configure cron job.


The annotation, which is used for the constraints of the `anydata[]` type.


The annotation, which is used for the constraints of the `Date` type, which is structurally equivalent
to the following record:
```ballerina
type Date record {
   int year;
   int month;
   int day;
};
```
This annotation will enable validation on the date fields in the record. Additionally,
the `option` field can be used to validate the date against the provided option.


The annotation, which is used for the constraints of the `float` type.


The annotation, which is used for the constraints of the `int` type.


The annotation, which is used for the constraints of the `int`, `float`, and `decimal` types.


The annotation, which is used for the constraints of the `string` type.


The annotation is used to overwrite the existing record field name.


The annotation is used to denote a field that can contain xsd:any type value.
When using `toXml`, this annotation will use the actual type name of the value as the XML element name
instead of the field name.


The annotation is used to denote the field that is considered an attribute.
When using `parseString`, `parseBytes`, `parseStream`, `parseAsType`, this annotation can be used to
indicate the record field as an attribute.
When using `toXml`, this annotation can be used to add the attribute to the XML element.


Annotation to define schema rules for an XML choice in Ballerina.


Annotation to define schema rules for an XML element in Ballerina.


The annotation is used to specify the new name of the existing record name or field name according to the XML format.
When using `parseString`, `parseBytes`, `parseStream`, `parseAsType`, this annotation can be used to 
validate the name of the XML element with the record field or type.
When using `toXml`, this annotation can be used to override the name of field or type.


The annotation is used to specify the namespace's prefix and URI of the XML element.
When using `parseString`, `parseBytes`, `parseStream`, `parseAsType`, this annotation can be used to 
validate the namespace of the XML element with the record field or type.
When using `toXml`, this annotation can be used to add the namespace to the XML element.


Annotation to define schema rules for an XML sequence in Ballerina.


Annotation to define schema rules for the sequence order in Ballerina.


Annotation to configure FTP service remote functions.
This can be used to specify which file patterns should be handled by a particular content method
and what actions to perform after processing.


Annotation to configure FTP service monitoring path and file patterns.
This annotation allows each service to define its own monitoring configuration,
enabling multiple services on a single listener to monitor different paths independently.


Represents the annotation of the ID type.


The annotation to configure a GraphQL interceptor.


The annotation to configure a GraphQL resolver.


The annotation to configure a GraphQL service.


The annotation to designate a GraphQL object type as a federated entity.


The annotation to designate a GraphQL service as a federated GraphQL subgraph.


The annotation which is used to configure a gRPC service.


The annotation which is used to define the response cache configuration. This annotation only supports `anydata` and
Success(2XX) `StatusCodeResponses` return types. Default annotation adds `must-revalidate,public,max-age=3600` as
`cache-control` header in addition to `etag` and `last-modified` headers.


The annotation which is used to configure the type of the response.


The annotation which is used to define the Header parameter.


The annotation which is used to define the Payload resource signature parameter and return parameter.


The annotation which is used to define the query parameter.


The annotation which is used to configure an HTTP resource.


The annotation which is used to configure an HTTP service.


Describes the Java class representing a Ballerina binding.
```ballerina
@java:Binding {
  'class: "java.io.File"
}
```


Describes a Java constructor, which provides an implementation of a Ballerina function of which the body is marked as
`external`. If the Ballerina function body is marked as `external`, it means that the implementation of the
function is not provided in the Ballerina source module.

The following code snippet shows an example usage of this annotation. Here, the `newJavaLinkedList` Ballerina function's
implementation is provided by the default constructor of the `java.util.LinkedList` class.
```ballerina
function newJavaLinkedList() returns handle = @java:Constructor {
     'class: "java.util.LinkedList"
} external;
```


Identifies a type, class, or function that is used in the Java native code. This annotation should be added by the
developer if the type, class, or function could be accessed via runtime APIs such as `ValueCreator`.
```ballerina
@java:ExternalDependency
function foo(int x) returns int => x * 2;
```


Describes a Java Field access, which provides an implementation of a Ballerina function of which the body is marked as
`external`.
```ballerina
function getError() returns handle = @java:FieldGet {
    name:"err",
    'class:"java/lang/System"
} external;
```


Describes a Java Field mutate, which provides an implementation of a Ballerina function of which the body is marked as
`external`.
```ballerina
function setContractId(handle contractId) = @java:FieldSet {
  name:"contractId",
  'class:"org/lang/impl/JavaFieldAccessMutate"
} external;
```


Describes a Java method, which provides an implementation of a Ballerina function of which the body is marked as
`external`. If the Ballerina function body is marked as `external`, it means that the implementation of the
function is not provided in the Ballerina source module.

The following code snippet shows an example usage of this annotation. Here, the `getUUID` Ballerina function's
implementation is provided by the `java.util.UUID.randomUUID` static method.
```ballerina
function getUUID() returns handle = @java:Method {
    name: "randomUUID",
    'class: "java.util.UUID"
} external;
```
The `name` field is optional. If it is not provided, the name of the Java method is inferred
from the Ballerina function.


Denotes that the body of a function has to be generated at compile-time.


Marks a record field or type as sensitive, excluding it from log output
The default strategy is to exclude the field from log output


Annotation to provide service configuration to MCP services.


Annotation to mark a function as an MCP tool configuration.


This is used for making a function observable.
Can be applied to functions which are not observable by default to make them observable.



Annotation for additional OpenAPI information of a Ballerina resource function.


Annotation for additional OpenAPI information of a Ballerina service.


The Annotation used to specify which database column matches the Typed record field.


Identifies test factory function for dynamic test registration.
Identifies beforeSuite function.


The annotation which is used to configure local transaction participant function.


The annotation which is used to configure the dispatching rules for WebSocket remote functions.


The annotation which is used to configure a WebSocket service.


WebSub Subscriber Configuration for the service, indicating subscription related parameters.


WebSub Hub Configuration for the service.


The annotation is used to denote the field that is considered an attribute.
In the XML-record conversion, this annotation can be used to add XML attribute using the `xmldata:toXML` API and
validate the XML attribute with record fields in the `xmldata:fromXml` API.


The annotation is used to specify the new name of the existing record name or field name according to the XML format.
In the XML-record conversion, this annotation can be used to override the default XML element name using the
`xmldata:toXML` API and validate the overridden XML element name with record field using the `xmldata:fromXml` API.


The annotation is used to specify the namespace's prefix and URI of the XML element.
In the XML-record conversion, this annotation can be used to add XML namespace using the `xmldata:toXML` API and
validate the the XML namespace with record in the `xmldata:fromXml` API.


Represents a contextual storage object used to pass additional data to tools during agent execution.


Represents a Genereric document chunker.
Provides functionality to recursively chunk a text document using a configurable strategy.

The chunking process begins with the specified strategy and recursively falls back to
finer-grained strategies if the content exceeds the configured `maxChunkSize`. Overlapping content
between chunks can be controlled using `maxOverlapSize`.


Represents an HTML document chunker.
Provides functionality to recursively chunk a HTML document using a configurable strategy.

The chunking process begins with the specified strategy and recursively falls back to
finer-grained strategies if the content exceeds the configured `maxChunkSize`. Overlapping content
between chunks can be controlled using `maxOverlapSize`.


Defines a HTTP tool kit. This is a special type of tool kit that can be used to invoke HTTP resources.
Require to initialize the toolkit with the service url and http tools that are belongs to a single API. 


Provides an in-memory chat message store.


An in-memory vector store implementation that provides simple storage for vector entries.


Represents a Markdown document chunker.
Provides functionality to recursively chunk a markdown document using a configurable strategy.

The chunking process begins with the specified strategy and recursively falls back to
finer-grained strategies if the content exceeds the configured `maxChunkSize`. Overlapping content
between chunks can be controlled using `maxOverlapSize`.


Represents a toolkit for interacting with an MCP server, invoking tools via the MCP protocol.


Provides an in-memory chat message window with a limit on stored messages.



Represents short-term memory for agents.


Dataloader that can be used to load supported file types as `TextDocument`s.
Currently only supports `pdf`, `docx`, `markdown`, `html`, and `pptx` file types.


Represents a vector knowledge base for managing chunk indexing and retrieval operations.
The `VectorKnowledgeBase` handles converting chunks to embeddings,
storing them in a vector store, and enabling retrieval through a `Retriever`.


Represents a retriever that finds relevant chunks based on query similarity.
The `Retriever` combines query embedding generation and vector search
to return matching chunks along with their similarity scores.


Chat-specific LLM span implementation for chat operations.


Represents a tracing span for creating an agent.


Represents a tracing span for creating a knowledge base.


Represents a tracing span for embedding model operations.


Represents a tracing span for executing a tool.


Generate-content specific LLM span implementation.


Represents a tracing span for invoking an agent.


Represents a tracing span for ingesting data into a knowledge base.


Represents a tracing span for retrieving data from a knowledge base.


Represents the client Basic Auth provider, which is used to authenticate with an external endpoint by generating a
Basic Auth token against the provided credential configurations.
```ballerina
auth:CredentialsConfig config = {
    username: "tom",
    password: "123"
}
auth:ClientBasicAuthProvider provider = new(config);
```


Represents the file user store based listener Basic Auth provider, which is used to authenticate the provided
credentials against the provided file user store configurations.
```ballerina
auth:ListenerFileUserStoreBasicAuthProvider provider = new;
```
The users are denoted by a section in the `Config.toml` file. The username, password, and the scopes of a particular
user are denoted as keys under the users section as shown below. For multiple users, the complete section has to be
duplicated.
```
[[ballerina.auth.users]]
username = "alice"
password = "password1"
scopes = ["scope1", "scope2"]
```


Represents the LDAP-based listener Basic Auth provider, which is used to authenticate the provided credentials
against the provided LDAP user store configurations. This connects to an active directory or an LDAP, retrieves
the necessary user information, and performs authentication and authorization.
```ballerina
auth:LdapUserStoreConfig config = {
    domainName: "ballerina.io",
    connectionURL: "ldap://localhost:389",
    connectionName: "cn=admin,dc=avix,dc=lk"
};
auth:ListenerLdapUserStoreBasicAuthProvider provider = new(config);
```


The avro schema implementation to support Avro serialization and deserialization.


The `cache:Cache` object, which is used for all the cache-related operations. It is not recommended to insert `()`
as the value of the cache since it doesn't make any sense to cache a nil.


The GraphQL context object used to pass the meta information between resolvers.


Represents the information about a particular field of a GraphQL document.


Represents a default implementation of the DataLoader.


Defines the Basic Auth handler for client authentication.


Defines the Bearer token auth handler for client authentication.


Defines the self signed JWT handler for client authentication.


Defines the file store Basic Auth handler for listener authentication.


Defines the JWT auth handler for listener authentication.


Represents a default persistent cookie handler, which stores persistent cookies in a CSV file.



Represents the headers of the inbound request.


Implements a cache for storing HTTP responses. This cache complies with the caching policy set when configuring
HTTP caching in the HTTP client endpoint.



Represents a 'future' that returns as a result of an asynchronous HTTP request submission.
This can be used as a reference to fetch the results of the submission.


Implementation of round robin load balancing strategy.



Represents an HTTP/2 `PUSH_PROMISE` frame.



Configures the cache control directives for an `http:Request`.



Represents an HTTP Context that allows user to pass data between interceptors.


Configures cache control directives for an `http:Response`.



Represents the status code of `STATUS_ACCEPTED`.



Represents the status code of `STATUS_ALREADY_REPORTED`.



Represents the status code of `STATUS_BAD_GATEWAY`.



Represents the status code of `STATUS_BAD_REQUEST`.



Represents the status code of `STATUS_CONFLICT`.



Represents the status code of `STATUS_CONTINUE`.



Represents the status code of `STATUS_CREATED`.



Represents the status code of `STATUS_EARLY_HINTS`.



Represents the status code of `STATUS_EXPECTATION_FAILED`.



Represents the status code of `STATUS_FAILED_DEPENDENCY`.



Represents the status code of `STATUS_FORBIDDEN`.



Represents the status code of `STATUS_FOUND`.



Represents the status code of `STATUS_GATEWAY_TIMEOUT`.



Represents the status code of `STATUS_GONE`.



Represents the status code of `STATUS_HTTP_VERSION_NOT_SUPPORTED`.



Represents the status code of `STATUS_IM_USED`.



Represents the status code of `STATUS_INSUFFICIENT_STORAGE`.



Represents the status code of `STATUS_INTERNAL_SERVER_ERROR`.



Represents the status code of `STATUS_LENGTH_REQUIRED`.



Represents the status code of `STATUS_LOCKED`.



Represents the status code of `STATUS_LOOP_DETECTED`.



Represents the status code of `STATUS_METHOD_NOT_ALLOWED`.



Represents the status code of `STATUS_MISDIRECTED_REQUEST`.



Represents the status code of `STATUS_MOVED_PERMANENTLY`.



Represents the status code of `STATUS_MULTIPLE_CHOICES`.



Represents the status code of `STATUS_MULTI_STATUS`.



Represents the status code of `STATUS_NETWORK_AUTHENTICATION_REQUIRED`.



Represents the status code of `STATUS_NO_CONTENT`.



Represents the status code of `STATUS_NON_AUTHORITATIVE_INFORMATION`.



Represents the status code of `STATUS_NOT_ACCEPTABLE`.



Represents the status code of `STATUS_NOT_EXTENDED`.



Represents the status code of `STATUS_NOT_FOUND`.



Represents the status code of `STATUS_NOT_IMPLEMENTED`.



Represents the status code of `STATUS_NOT_MODIFIED`.



Represents the status code of `STATUS_OK`.



A client class for interacting with a chat service.


WSO2 embedding provider implementation that provides embedding capabilities using WSO2's AI service.


WSO2 model provider implementation that provides chat completion capabilities using WSO2's AI services.


Represents an IMAP Client, which interacts with an IMAP Server.


Represents a POP Client, which interacts with a POP Server.


Represents an SMTP Client, which interacts with an SMTP Server.


FTP caller for interacting with FTP/SFTP servers from within file handlers.
Provides the same file operations as the Client class.


FTP client for connecting to and managing FTP/SFTP servers.
Supports reading files in various formats (text, JSON, XML, CSV, bytes) and writing files with overwrite or append options.


The Ballerina GraphQL client that can be used to communicate with GraphQL APIs.


The base client used in the generated client code to provide remote functions for interacting with the caller.



The base client used in the generated client code to provide the capability for initiating the contact and executing remote calls with a remote gRPC service.


Defines the OAuth2 handler for client authentication.


Defines the LDAP store Basic Auth handler for listener authentication.


Defines the OAuth2 handler for listener authentication.


This is used for internal purposes to support reflection.


The base client used in the generated client code to provide the gRPC streaming client actions for
interacting  with the gRPC server.


The caller actions for responding to client requests.



The HTTP client provides functionality to connect to remote HTTP services and perform requests using standard HTTP methods like GET, POST, PUT, DELETE, etc.



An HTTP client endpoint which provides failover support over multiple HTTP clients.



LoadBalanceClient endpoint provides load balancing functionality over multiple HTTP clients.



The HTTP status code client provides the capability for initiating contact with a remote HTTP service. The API it
provides includes the functions for the standard HTTP methods forwarding a received request and sending requests
using custom HTTP verbs. The responses can be binded to `http:StatusCodeResponse` types


Consists of APIs to integrate with LDAP.


Represents an MCP client built on top of the Streamable HTTP transport.


Represents the client that is used to complete received messages.


Represents the client that is used to publish messages to the server.


Object for the basic SOAP 1.1 client endpoint.


Object for the basic SOAP 1.2 client endpoint.


Represents caller object in tcp service remote methods.



Initializes the TCP connection client based on the provided configurations.


Represents caller object in UDP service remote methods.



Initializes the UDP connectionless client based on the provided configurations.


Initializes the UDP connection oriented client based on the 
provided configurations.


Represents a WebSocket synchronous client endpoint.


Represents resource-discovery service which identify the `hub` and `topic` from `resource-URL`.


The HTTP based client for WebSub subscription and unsubscription.


HTTP Based client for WebSub content publishing to subscribers


The HTTP based client for WebSub topic registration and deregistration, and notifying the hub of new updates.


Represent the automatic chunker configuration in the `VectorKnowledgeBase`.
This chunker will be chosen automatically based on the document type.


Represents the disabled chunker configuration in the `VectorKnowledgeBase`.
This chunker will not perform any chunking and will treat the entire document as a single chunk.


No padding for encryption or decryption.


The OAEP padding mode with MD5 and MGF1 for RSA encryption and decryption.


The OAEP padding mode with SHA-1 and MGF1 for RSA encryption and decryption.


The OAEP padding mode with SHA-256 and MGF1 for RSA encryption and decryption.


The OAEP padding mode with SHA-384 and MGF1 for RSA encryption and decryption.


The OAEP padding mode with SHA-512 and MGF1 for RSA encryption and decryption.


The PKCS1 padding mode for RSA encryption and decryption.


The PKCS5 padding mode for AES encryption and decryption.


Delete action for file processing.
When specified, the file will be deleted after processing.


The prefix used to denote the Basic authentication scheme.


The prefix used to denote the Bearer authentication scheme.


Always set accept-encoding/content-encoding in outbound request/response.


ballerinax/azure_storage_service Ballerina library

Overview

Key Features

Compatibility

Report issues

Useful links

Errors

azure_storage_service: Error

	Version
Ballerina Language	Ballerina Swan Lake 2201.3.0
Azure Storage Service	2019-12-12

errors